Side-by-Side Subsystem Execution on Shared Base OS
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current solutions for running applications designed for different operating systems on a single device are memory-intensive, as they require executing two full operating systems with their respective kernels and drivers simultaneously, which is inefficient.
Innovation Solution
The method involves loading multiple API set schemas into memory and using a runtime context evaluator to resolve API calls to the appropriate host binaries, allowing same-type subsystems from different operating systems to co-execute on a single base operating system, eliminating the need for a virtual machine.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If a virtual machine is used to run two different operating systems side-by-side, then applications designed for different operating systems can execute simultaneously, but memory consumption increases significantly due to the overhead of running two full operating systems including kernels and drivers
Solution Approach 1:
The patent segments the operating system into two distinct parts: a shared base operating system (kernel and drivers) that runs once, and multiple subsystems (Windows Desktop subsystem and Windows Mobile subsystem) that can co-execute. This segmentation allows applications designed for different operating systems to run simultaneously without duplicating the entire OS, thereby reducing memory consumption while maintaining the ability to execute diverse applications.
Solution Approach 2:
The patent merges multiple operating system requirements into a single base operating system instance. Instead of running two separate OS instances (which would duplicate kernels and drivers), the invention combines the functionality of multiple OSes by loading different subsystems onto a shared base OS, allowing Windows Desktop and Windows Mobile applications to co-execute on the same device with shared system resources.
2Adaptability or versatility
If two full operating systems are executed simultaneously to support different applications, then compatibility with applications designed for different operating systems is achieved, but system efficiency decreases due to redundant execution of kernels and drivers
Solution Approach 1:
The patent segments the operating system into a shared base layer (kernel and drivers) and separate subsystem layers (Windows Desktop subsystem, Windows Mobile subsystem). This segmentation enables different application types to run simultaneously while sharing the common infrastructure, eliminating redundant execution of kernels and drivers and improving system efficiency.
Solution Approach 2:
The base operating system is designed to be universal, capable of supporting multiple subsystems simultaneously. The single base OS instance provides common services to both Windows Desktop and Windows Mobile applications, making the system multi-functional and able to handle diverse application requirements without sacrificing efficiency.
3Adaptability or versatility
If multiple API set schemas are loaded into memory to resolve API calls to different host binaries, then same-type subsystems from different operating systems can co-execute, but memory usage increases
Solution Approach 1:
The patent implements local quality by loading multiple API set schemas selectively based on runtime context. Instead of loading all possible API schemas simultaneously, the system evaluates the runtime context and loads only the specific API set schema needed for the current subsystem execution, thereby reducing overall memory usage while maintaining the ability to support multiple subsystems.
Solution Approach 2:
The API set schema loading is made dynamic through the runtime context evaluator. The system dynamically determines which API set schema to load based on the current execution context, allowing flexible adaptation to different subsystem requirements without permanently allocating memory for all possible schemas. This dynamic approach optimizes memory usage while preserving subsystem co-execution capability.
Data Source
Figure 1
Figure 2
Figure 3
AI summary
A method for executing side-by-side same-type subsystems includes multiple application programming interface (API) set schemas into memory. A first one of the API set schemas resolves an API set contract to a first host binary and a second one of the API set schemas resolves the API set contract to a different host binary. The method further includes executing elements of the first host binary responsive to receipt of an API call identified by the API set contract that is received within a first runtime context and executing elements of the second host binary responsive to receipt of the API call within a second runtime context.