Dynamic Module Code Indexing and Loading
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current methods for loading program codes on computing devices often require uploading numerous module codes, many of which are not needed for specific actions, leading to inefficient data transfer and storage, as they either statically load all modules or dynamically load them with preloaded indexes, which can be large and complex.
Innovation Solution
A method and system that dynamically index and load module codes by receiving a request for an action, acquiring module code references from predetermined indexes, and retrieving the necessary module codes from their respective locations, allowing for efficient loading and execution of only required codes.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Speed
If static loading is used to load all modules at initial loading, then all required modules are guaranteed to be available ensuring program responsiveness, but data transfer traffic increases extensively since all modules are loaded including those never executed
Solution Approach 1:
The patent implements dynamic module loading where the system transitions from static pre-loading to runtime-based loading. Modules are loaded only when their dependencies are actually needed during program execution, allowing the loading strategy to adapt dynamically to actual runtime requirements rather than assuming all possible modules may be needed.
Solution Approach 2:
The system performs preliminary actions by pre-loading only the dependency information and module indexes rather than the actual module codes. This preliminary loading of metadata enables fast dependency resolution while the actual module codes are loaded on-demand, combining the benefits of preparation with reduced initial data transfer.
2Loss of energy
If dynamic loading is used to load modules at runtime based on explicit program instruction, then data transfer traffic is reduced, but the system still needs to preload large module code indexes depicting module dependencies and data permissions
Solution Approach 1:
The patent segments the module information into two distinct parts: lightweight dependency metadata (loaded preliminarily) and actual module codes (loaded on-demand). This segmentation separates the small index structure that describes module relationships from the large module code bodies, allowing the system to load only the essential dependency information initially without burdening the system with large index files.
Solution Approach 2:
The system extracts and removes the actual module code data from the preliminary loading phase, keeping only the essential dependency metadata. This extraction allows the heavy module code indexes to be eliminated from the pre-loading stage, with only lightweight dependency information being loaded initially, and actual codes fetched later when needed.
3Reliability
If all modules are uploaded to local information storage memory on initial loading, then program execution can proceed without network dependency, but storage space is consumed by modules whose program instructions are never actually executed
Solution Approach 1:
The patent implements dynamic local storage management where module codes are transferred from remote to local storage dynamically based on actual execution needs. The system monitors runtime dependencies and selectively loads only those modules that will be executed, allowing storage capacity to adapt dynamically rather than being statically allocated for all possible modules.
Solution Approach 2:
The system employs self-service mechanisms by automatically tracking its own dependency requirements during runtime and autonomously loading only the necessary module codes. The program monitors its own execution path and retrieves additional modules from the network as needed, eliminating the need to pre-store all possible modules locally.
Data Source
AI summary
Computing device and a method for loading module codes, the module codes required for executing an action, the method comprising: receiving, by the computing device, a request for executing the action, the action being executable using a first module code; acquiring, from the first predetermined index a first module code reference indicating a first module code location and the indication that executing the first module code requires a second module code; acquiring, from a second predetermined index, a second module code reference, the second module code reference indicating a second module code location; based on the first module code reference, acquiring the first module code from the first module code location; based on the second module code reference, acquiring the second module code from the second module code location; executing the action by running the first module code and the second module code.