Page-In Linking for On-Demand Symbol Resolution
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing operating systems incur significant memory and computational costs due to the dynamic linking of symbol references during process start-up, leading to increased process memory usage and dirty memory creation.
Innovation Solution
Implementing page-in linking, where symbol references are resolved on-demand as pages are paged into process memory, using a dynamic linker and kernel to manage the resolution process, reducing the need for upfront resolution of all symbol references upon process start-up.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If symbol references are resolved upfront during process start-up, then all symbol references are available for execution, but memory usage and computational costs increase significantly
Solution Approach 1:
The dynamic linker performs preliminary identification of symbol references in pages before they are executed. When a page is paged into process memory, the dynamic linker proactively resolves symbol references in that page by generating resolution data and sending it to the kernel, ensuring symbols are available before execution begins. This preliminary action prevents delays during runtime while avoiding the need to resolve all symbols upfront.
Solution Approach 2:
The system divides the symbol reference resolution process into page-level segments. Instead of resolving all symbols in the entire process at once, the dynamic linker processes pages individually as they are paged into memory. Each page's symbol references are resolved independently, reducing the memory burden at any given time while ensuring complete symbol availability when needed.
2Productivity
If all symbol references are resolved during process start-up, then execution can proceed without delays, but computational costs and dirty memory creation increase
Solution Approach 1:
The system performs partial symbol reference resolution only for pages that are actually paged into process memory and executed. Instead of resolving all symbol references in the entire process regardless of whether they are needed, the dynamic linker focuses computational effort on the subset of pages currently in memory, reducing wasted computational resources on unused code.
Solution Approach 2:
The symbol resolution process becomes dynamic and adaptive to the actual execution needs. As pages are dynamically paged in and out of process memory, the dynamic linker continuously identifies and resolves symbol references in the currently active pages. This dynamic approach ensures symbols are available when needed without maintaining unnecessary resolved symbols in memory.
3Quantity of substance
If symbol references are resolved on-demand as pages are paged in, then memory usage is reduced, but the resolution process must be managed dynamically between dynamic linker and kernel
Solution Approach 1:
The dynamic linker acts as an intermediary between the page-fault handler and the kernel's symbol resolution mechanism. When a page is paged into process memory, the dynamic linker receives notification, identifies symbol references in that page, generates resolution data, and sends it to the kernel for resolution. This intermediary role streamlines the interaction and provides a clear interface for managing on-demand symbol resolution.
Data Source
AI summary
A dynamic linking system can be designed to dynamically resolve symbol references of pages associated with executable code as the pages are paged into virtual memory. The operating system can include a dynamic linker that uses metadata in the pages to determine symbol references that reference other code or values. Other code can include code in shared libraries. The dynamic linker can generate a data structure containing the symbol references in a small and dense format. The dynamic linker can send the data structure and other relevant data to the kernel once the symbol references have been identified. The kernel can perform the functions related to resolving the symbol references. For example, the kernel can resolve the symbol by determining a pointer value for the symbol, wherein the pointer value can be used to point to code or values. The kernel can resolve the symbol references and store the data structure, which contains the resolved symbol references.