Segmented VM Latency Reduction via Eager Buffering
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Segmented virtual machines experience significant latency due to the need for remote procedure calls (RPCs) when passing interactions, such as reading or writing data streams, between the shell and core virtual machines, which can be exacerbated by large data transfers.
Innovation Solution
Implementing a transport mechanism that uses 'eager reading' and 'lazy writing' through buffers in both the shell and core virtual machines, where data is locally available and transferred only when buffers are full or periodic, reducing the reliance on RPCs and minimizing latency.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If remote procedure calls are used to pass interactions between shell VM and core VM, then the segmented virtual machine can forward interactions correctly, but latency increases significantly
Solution Approach 1:
The patent implements preliminary action by pre-establishing communication channels and buffers between the shell VM and core VM before interactions occur. The shell VM maintains a buffer that can store interaction data, and communication pathways are set up in advance, allowing data to be transferred without repeated RPC overhead during actual data-intensive operations.
Solution Approach 2:
The patent introduces an intermediary mechanism in the form of a buffer located in the shell VM that mediates data transfer between the core VM and external applications. This buffer acts as a intermediary storage layer that reduces the frequency of RPC calls by allowing batched or asynchronous data transfers, thereby reducing latency while maintaining correct interaction forwarding.
2Ease of operation
If data is read incrementally one byte at a time through RPC, then data can be processed sequentially, but latency accumulates significantly
Solution Approach 1:
The patent enables continuity of useful action by implementing a buffer-based system that allows data to be read and processed continuously without interruption for RPC overhead. The shell VM buffer can store multiple bytes or blocks of data, allowing the core VM to read data in larger, more efficient chunks rather than incrementally, maintaining continuous data flow while reducing per-operation latency.
Solution Approach 2:
The buffer is pre-configured in the shell VM to hold data before it is read by the core VM, allowing data to be staged in advance. This preliminary buffering action enables the core VM to read data in bulk rather than byte-by-byte through multiple RPC calls, reducing cumulative latency while maintaining ease of sequential processing through the buffer interface.
3Reliability
If frequent RPC calls are made for data transfer, then data can be transferred reliably, but performance deteriorates in data-intensive operations
Solution Approach 1:
The shell VM buffer serves as an intermediary that consolidates multiple small data transfer requests into fewer, larger transfer operations. By storing data in the buffer before transfer to the core VM, the system reduces the frequency of RPC calls while maintaining reliable data transfer, thereby improving productivity in data-intensive operations.
Solution Approach 2:
Data is preliminarily buffered in the shell VM before being transferred to the core VM, allowing batched transfers that reduce RPC call frequency. This preliminary buffering action maintains transfer reliability by ensuring data is properly staged and validated, while significantly improving performance by reducing the overhead of frequent RPC calls in data-intensive operations.
Data Source
AI summary
Providing data to an application running on a segmented virtual machine (VM) is disclosed. Providing data includes opening an interface between the segmented VM and an external data source, transferring data from the external data source to an interface buffer, transferring a first selected amount of data from the interface buffer to a shell VM buffer, transferring a second selected amount of data from the shell VM buffer to a core VM buffer, and providing portions of the data from the core VM buffer to the application in response to read requests from the application.