Runtime Object Graph Assembly via Scripted Native Instructions
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing technologies face challenges in assembling object graphs at runtime without class loaders and serialization/deserialization, particularly when using ahead-of-time compilers that compile code into native instructions, which can introduce security risks and limit system performance.
Innovation Solution
The implementation of graph assembly scripts and a state machine with a stack and addressable memory to assemble object graphs, allowing for code extensions by generating an object graph based on a business process definition, even in the absence of class loaders and serialization/deserialization, using assembler primitives that do not include labels, loops, or conditional statements to ensure a one-way flow and prevent resource-intensive delays.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If code is compiled to native instructions using an AOT compiler, then system performance is improved, but code extensibility at runtime is lost
Solution Approach 1:
The system segments code into two distinct parts: core business process code that is compiled to native instructions for performance, and extension code that is written in a scripting language for runtime extensibility. This allows the core system to benefit from AOT compilation performance while extensions can be dynamically added without recompiling the entire system.
Solution Approach 2:
The patent introduces a virtual machine as an intermediary layer between the native instruction set and the scripting language. The virtual machine executes both the compiled native code and the interpreted extension scripts, enabling seamless integration of performance-critical core code with extensible runtime code without requiring direct manipulation of native instructions for extensions.
2Adaptability or versatility
If class loaders and serialization/deserialization are used for code extension, then code extensibility is achieved, but security risks and system complexity increase
Solution Approach 1:
The patent extracts the code extension mechanism from the traditional Java class loader system. Instead of using class loaders that can introduce malicious code, the system uses a dedicated scripting language with a restricted instruction set that is interpreted by the virtual machine. This separation removes the security risks associated with arbitrary code execution while maintaining extensibility.
Solution Approach 2:
The patent changes the fundamental parameters of code extension by using a scripting language with a limited, predefined instruction set rather than full compiled language support. This parameter change in the type of code (from compiled to interpreted scripts) inherently limits the attack surface while preserving the ability to extend functionality at runtime.
3Adaptability or versatility
If graph assembly scripts include labels, loops, or conditional statements, then code flexibility is improved, but resource consumption and execution time increase
Solution Approach 1:
Instead of allowing the script to control the flow through labels, loops, and conditionals, the patent inverts the approach by providing a fixed iterative execution pattern and allowing the script to define what happens at each step. The virtual machine executes the script in a predetermined iterative manner, eliminating the need for flow control constructs while maintaining flexibility in defining object graph assembly behavior.
Data Source
AI summary
Techniques for script-based runtime assembly of object graphs using native instructions compiled by an ahead-of-time compiler are disclosed, including: generating, based on a data structure that defines a business process, a script including instructions for assembling an object graph that represents relationships between objects used by the business process; obtaining, at runtime by a business process execution engine compiled to native instructions by an ahead-of-time compiler, the script; assembling, at runtime by the business process execution engine, the object graph based at least on the instructions in the script.