Executable Graph Templates for Low-Latency Runtime Node Composition
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing n-tier architectures separate data storage from processing logic, leading to impedance mismatches and reduced flexibility, extensibility, and responsiveness, which is detrimental in time-critical applications.
Innovation Solution
The integration of data and data processing functionality within a single executable graph-based model, utilizing template-driven generation to combine data and processing logic dynamically at run-time, maintaining separability when offline.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of manufacture
If data and processing logic are separated into different tiers (n-tier architecture), then system modularity and maintainability are improved, but system flexibility and responsiveness deteriorate
Solution Approach 1:
The system segments processing logic into reusable overlays that can be independently developed and maintained, while allowing dynamic composition at runtime. Each overlay represents a modular unit of functionality that can be selectively applied to graph nodes, providing both modularity and flexibility.
Solution Approach 2:
The system employs runtime graph compilation where the structure and behavior of the system are determined dynamically based on input data. Graph nodes and overlays are composed at runtime rather than being fixed at deployment, allowing the system to adapt its behavior based on actual data characteristics and requirements.
2Ease of manufacture
If data and processing logic are separated into different tiers, then technical separation of concerns is achieved, but processing latency increases
Solution Approach 1:
The system merges data and processing logic into a unified graph-based model at runtime. The graph structure inherently combines data representation and processing behavior, eliminating the need for repeated data serialization and deserialization between tiers, thus reducing latency while maintaining separation of concerns through the overlay mechanism.
3Stability of the object's composition
If traditional n-tier architecture is used, then system stability and data integrity are maintained, but responsiveness to time-critical operations deteriorates
Solution Approach 1:
The system performs preliminary validation and structure definition through schema-based graph templates. Data integrity constraints are embedded in the graph schema and overlay definitions, allowing validation to occur during graph construction rather than during data access operations, thus maintaining integrity while improving responsiveness.
Data Source
AI summary
A method for loading run-time nodes of a template-based executable graph-based model is provided. A node instance manifest state is obtained based on a first node identifier associated with a node instance. The node instance manifest state includes a second node identifier associated with a node template. A node instance manifest is generated from the node instance manifest state. The node instance manifest comprises a first storage location and the first node identifier. A node instance state is obtained from the first storage location. The node template is obtained based on the second node identifier. The node instance is generated from the node instance manifest, the node instance state, and the node template. A run-time node, comprising a composition of the node instance and the node template, is generated.