Conservative Class Preloading for Real-Time Java Execution
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing methods for dynamically loading components in dynamic languages, such as Java, face inefficiencies due to the single inheritance class structure and resource constraints, leading to delayed loading and increased memory footprint, which is problematic for real-time applications.
Innovation Solution
A method that recursively identifies new execution points and classes, extending package private classes to create new public classes for preloading and verification, allowing for deterministic execution and efficient resource management.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Quantity of substance
If classes are loaded dynamically during runtime, then memory footprint is reduced, but startup time increases and execution becomes non-deterministic
Solution Approach 1:
The patent performs preliminary class loading and verification at application startup by recursively parsing instructions from execution points to identify all required classes beforehand. This preliminary action ensures that classes are loaded into memory before runtime execution begins, eliminating runtime loading delays and ensuring deterministic execution while maintaining efficient memory usage by loading only necessary classes.
Solution Approach 2:
The patent segments the class loading process into distinct phases: identification of execution points, recursive parsing to discover required classes, verification of package-private classes through proxy generation, and final loading. This segmentation allows systematic preloading of classes without overwhelming memory resources, resolving the contradiction between reduced memory footprint and faster startup.
2Reliability
If all required classes are preloaded, then execution becomes deterministic, but memory footprint increases
Solution Approach 1:
The patent applies partial action by loading only the specific classes that are actually required for execution, determined through recursive parsing from execution points. Rather than loading all available classes, it loads precisely what is needed, achieving execution determinism without unnecessary memory consumption.
Solution Approach 2:
The patent changes the parameter of class visibility by generating public proxy classes for package-private classes, enabling them to be loaded and verified. This parameter change allows selective loading of previously inaccessible classes without loading entire packages, optimizing memory footprint while ensuring deterministic execution.
3Quantity of substance
If package private classes are loaded directly, then memory usage is efficient, but loading fails due to accessibility restrictions
Solution Approach 1:
The patent introduces public proxy classes as intermediaries between the class loader and package-private classes. These proxy classes act as mediators that enable the loading and verification of package-private classes without directly accessing them, resolving the accessibility restriction while maintaining efficient memory usage by loading only necessary classes.
Solution Approach 2:
The patent creates copy representations of package-private classes through public proxy classes. These copies have the same structure and behavior but with public accessibility, allowing them to be loaded and verified without modifying the original package-private classes or their memory footprint.
Data Source
AI summary
A computer implemented method, a computer program product and a data processing system for executing an application written in a dynamic language are provided. An execution point of the application is loaded. A list of classes associated with the execution point is generated. The loading of each class in the list of classes is simulated. New execution points and new classes accessible from each execution point within each class in the list of classes are identified by recursively parsing instructions associated with each execution point. The list is modified to include the identified new execution points and new classes. Responsive to a determination that new execution points and new classes have been identified, the steps of identifying new execution points and new classes and modifying the list is repeated. The list is saved.