Process Local Storage Access via Attach Detach Mechanism
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing mechanisms for process local storage sharing in computer systems are complex and inefficient, particularly for server processes that need to access large quantities of data from client processes, often requiring intermediate copies and general-purpose operating system kernel functions that impact performance.
Innovation Solution
An operating system kernel with an attach and detach mechanism that allows a server process to directly access a client process's local storage using the client's local addresses, with processes tagged as either client or server to lay out the address space accordingly, enabling controlled access and efficient data sharing.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If shared memory or memory mapped files are used for process storage sharing, then processes can share storage, but the mechanism becomes complex and requires explicit cooperation between processes
Solution Approach 1:
The patent introduces an intermediary mechanism (the attach/detach interface and associated data structures) that mediates between server and client processes. This intermediary handles the complexity of storage sharing internally, allowing processes to access each other's storage through simple attach/detach operations without needing to understand the underlying sharing mechanism complexity
Solution Approach 2:
The patent creates a universal attach/detach mechanism that can be used by any server process to access any client process's storage, regardless of the specific storage layout or process architecture. This multi-functional interface simplifies the complexity by providing a single, standardized way to share storage across different process types and storage configurations
2Ease of operation
If general-purpose operating system kernel functions are used for data access, then data can be accessed between processes, but performance is impacted due to overhead
Solution Approach 1:
The patent extracts the essential data access functionality from general-purpose operating system kernel functions and implements it directly in user space through the attach/detach mechanism. By taking out only the necessary data access operations and implementing them efficiently in user space, the system maintains ease of operation while eliminating the performance overhead of kernel function calls
Solution Approach 2:
Once a server process attaches to a client process's storage, it can directly access and manipulate the client's storage structures without requiring continuous kernel intervention. The server process serves itself by directly operating on the client's storage, eliminating the need for repeated kernel function calls and improving performance
3Adaptability or versatility
If intermediate copies are used for data transfer between processes, then data can be shared, but efficiency is reduced due to copying overhead
Solution Approach 1:
The patent merges the server process's address space with the client process's storage by establishing direct pointers and references. Instead of creating separate intermediate copies, the server process's address space is combined with views into the client's storage, allowing direct access without copying overhead while maintaining adaptability for different data transfer scenarios
Data Source
AI summary
An operating system kernel includes an attach mechanism and a detach mechanism. In addition, processes are tagged with an access attribute identifying the process as either a client process or a server process. Based on the access attribute, the operating system kernel lays out the process local address space differently depending on whether the process is a client process or a server process. A server process can “attach” to a client process and reference all of the client process' local storage as though it were its own. The server process continues to reference its own process local storage, but in addition, it can reference the other storage, using the client process' local addresses. When access to the other storage is no longer needed, the server process can “detach” from the client process. Once detached, the other storage can no longer be referenced.