Dynamic Shared Library Loading for Memory Conservation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Deploying new software applications in information handling systems often requires updating the target software stack, which can be intrusive and wasteful in terms of memory usage, especially when redundant libraries are loaded into volatile memory.
Innovation Solution
Deploying new software application features as dynamically-loadable executable packages that can be executed with or without dependent shared libraries, leveraging non-volatile memory to conserve scarce volatile memory space by selectively loading only needed libraries.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If updated shared libraries are dynamically linked to the application, then the application can use the latest library versions, but the installation of additional library packages becomes intrusive to system stability and other applications
Solution Approach 1:
The patent segments the library dependency resolution into two independent paths: (1) a static embedding path where library code is copied into the application image, and (2) a dynamic linking path where existing shared libraries are referenced at runtime. This segmentation allows the system to choose the appropriate path based on whether libraries are already available in the target stack, avoiding intrusive updates while maintaining compatibility.
Solution Approach 2:
The patent introduces an intermediary mechanism (the runtime loader with embedded file system image) that mediates between the application's library needs and the system's existing library stack. This intermediary can selectively extract and embed only the necessary library portions into the application image, acting as a buffer that prevents direct modification of system-wide library packages and thus maintains system stability.
2Reliability
If updated shared libraries are statically linked to the application, then the dynamically-linked shared libraries do not have to be updated, but the runtime memory usage increases when libraries are already available in the target stack
Solution Approach 1:
The patent makes the library loading approach dynamic rather than static. The runtime loader examines whether the required shared libraries are already present in the target stack's shared memory space. If they are available, the loader references them dynamically without embedding copies. If they are not available, the loader extracts and embeds the necessary library code into the application image. This dynamic decision-making optimizes memory usage while ensuring reliability.
Solution Approach 2:
The patent changes the parameter of library loading based on availability conditions. When libraries are already in the target stack, the system uses dynamic referencing (lower memory overhead). When libraries are missing, the system switches to embedding (ensuring self-containment). This parameter change based on runtime conditions resolves the contradiction between memory efficiency and reliability.
3Ease of operation
If all dependent shared libraries are embedded into the application image, then the application is self-contained and can execute without external libraries, but redundant libraries are loaded into volatile memory wasting scarce memory space
Solution Approach 1:
The patent applies partial action by embedding only the necessary library portions into the application image rather than all possible libraries. The runtime loader determines which libraries are actually needed by the application and embeds only those, avoiding the excessive action of embedding every possible library. This partial embedding approach ensures executability while minimizing redundant memory consumption.
Solution Approach 2:
The patent extracts only the essential library code from the full library packages and embeds just those portions into the application image. The runtime loader identifies the minimal set of library functions required by the application and extracts only those, leaving the rest of the library packages unused. This extraction approach enables self-containment while avoiding the waste of loading redundant libraries into volatile memory.
Data Source
AI summary
Systems and methods are provided for deploying new software application features as a dynamically-loadable executable package including one or more dynamically-linked shared dependent libraries. The dynamically-loadable executable package may be capable of being loaded into volatile memory and executed in an information handling system environment with or without the dependent shared libraries, and without duplicating the presence or use of redundant shared libraries that may be already present on the existing software stack.