Shared Code Caching Engine for Inter-Process Memory Efficiency
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing software code caching systems face challenges in inter-process sharing due to memory consumption issues, synchronization problems with source application code, and security concerns when trying to maintain and update code caches across multiple processes.
Innovation Solution
A method and apparatus for caching computer code using non-volatile memory and volatile memory, enabling inter-process sharing of code caches while minimizing memory usage and security risks through a shared code caching engine that pre-loads and manages code cache files, ensuring cache coherency and security by validating and merging data across different processes.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If code caching is applied simultaneously to many processes, then code execution efficiency is improved, but memory consumption increases significantly
Solution Approach 1:
The patent merges code caches from multiple processes into a single shared cache structure. Instead of each process maintaining its own separate code cache, the system combines cached code from multiple processes into one shared repository, allowing all processes to benefit from code caching while sharing the memory burden collectively, thus improving overall code execution efficiency without linearly increasing total memory consumption.
Solution Approach 2:
The shared code cache structure serves multiple processes simultaneously, making it a universal resource. The cache is designed to be accessed and utilized by multiple processes for different code segments, providing multi-functional utility. This allows the same memory space to serve multiple purposes and multiple processes, thereby improving code execution efficiency across all processes without proportionally increasing memory consumption.
2Quantity of substance
If code caches are shared across processes, then memory consumption is reduced, but synchronization and security problems arise
Solution Approach 1:
The patent implements feedback mechanisms to monitor and maintain cache coherency across processes. The system tracks code modifications in source applications and provides feedback to update the shared code cache accordingly. This feedback loop ensures that the shared cache remains synchronized with the original source code, maintaining reliability and cache coherency while enabling memory-efficient shared caching across multiple processes.
Solution Approach 2:
The patent introduces an intermediary layer between the source application code and the shared code cache. This intermediary manages the complexity of synchronization and security by handling cache validation, updating, and protection mechanisms. The intermediary absorbs the complexity of maintaining cache coherency and security, allowing multiple processes to share the cache efficiently without directly managing the complex synchronization requirements themselves.
3Reliability
If code caches are kept synchronized with source application code, then code reliability is maintained, but complexity of managing updates and patches increases
Solution Approach 1:
The patent extracts the complexity of cache synchronization and management from the individual processes and centralizes it in a dedicated cache management system. By separating the cache management functionality from the application processes, the system maintains code reliability through centralized control while reducing the complexity burden on individual processes. The management system handles updates, patches, and synchronization independently, allowing processes to simply access the shared cache without managing its complexity.
Data Source
AI summary
Computer code from an application program comprising a plurality of modules that each comprise a separately loadable file is code cached in a shared and persistent caching system. A shared code caching engine receives native code comprising at least a portion of a single module of the application program, and stores runtime data corresponding to the native code in a cache data file in the non-volatile memory. The engine then converts cache data file into a code cache file and enables the code cache file to be pre-loaded as a runtime code cache. These steps are repeated to store a plurality of separate code cache files at different locations in non-volatile memory.