US-12619661-B2 - Systems and methods for templating of executable graph-based models

US12619661B2US 12619661 B2US12619661 B2US 12619661B2US-12619661-B2

Abstract

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.

Inventors

Steven SCHILDERS

Assignees

Infosys Limited
INVERTIT INC.

Dates

Publication Date: 20260505
Application Date: 20241028

Claims (13)

1 . A method for loading run-time nodes of a template-based executable graph-based model, comprising: obtaining, by processing circuitry, a node instance manifest state based on a first unique node identifier associated with a node instance, wherein the node instance manifest state comprises a second unique node identifier associated with a node template; generating, by the processing circuitry, a node instance manifest from the node instance manifest state, wherein the node instance manifest comprises a first storage location and the first unique node identifier; obtaining, by the processing circuitry, a node instance state from the first storage location; obtaining, by the processing circuitry, the node template based on the second unique node identifier associated with the node template; generating, by the processing circuitry, the node instance from the node instance manifest, the node instance state, and the node template; and generating, by the processing circuitry, a run-time node comprising a composition of the node instance and the node template.
2 . The method of claim 1 , wherein obtaining the node template comprises: obtaining, by the processing circuitry, a node template manifest state based on the second unique node identifier associated with the node template; generating, by the processing circuitry, a node template manifest from the node template manifest state, wherein the node template manifest comprises a second storage location and the second unique node identifier; obtaining, by the processing circuitry, a node template state from the second storage location; and generating, by the processing circuitry, the node template from the node template manifest and the node template state.
3 . The method of claim 1 , further comprising: obtaining, by the processing circuitry, an executable node instance manifest state based on the first unique node identifier associated with the node instance, wherein the executable node instance manifest state comprises the first unique node identifier and a third unique node identifier associated with a first overlay instance; generating, by the processing circuitry, an executable node instance manifest from the executable node instance manifest state, wherein the executable node instance manifest comprises a third storage location and the first unique node identifier; obtaining, by the processing circuitry, an executable node instance state from the third storage location; obtaining, by the processing circuitry, a first run-time overlay based on the third unique node identifier, wherein the first run-time overlay comprises the third unique node identifier, the first overlay instance, and a first overlay template associated with the first overlay instance; and generating, by the processing circuitry, an executable node instance based on the node instance, the executable node instance manifest, the executable node instance state, and the first run-time overlay, wherein the run-time node is generated using the executable node instance such that the composition of the run-time node comprises the executable node instance and the node template.
4 . The method of claim 1 , further comprising: obtaining, by the processing circuitry, an executable node template manifest state based on the second unique node identifier associated with the node template, wherein the executable node template manifest state comprises the second unique node identifier and a third unique node identifier associated with a second overlay template; generating, by the processing circuitry, an executable node template manifest from the executable node template manifest state, wherein the executable node template manifest comprises a fourth storage location and the second unique node identifier; obtaining, by the processing circuitry, an executable node template state from the fourth storage location; obtaining, by the processing circuitry, the second overlay template based on the third unique node identifier; and associating, by the processing circuitry, the node template and the second overlay template.
5 . The method of claim 4 , further comprising: obtaining, by the processing circuitry, a second overlay instance based on a fourth unique node identifier, wherein the executable node template manifest comprises the fourth unique node identifier; generating, by the processing circuitry, a second run-time overlay comprising a composition of the second overlay template and the second overlay instance; and generating, by the processing circuitry, an executable node template based on the node template, the executable node template manifest, the executable node template state, and the second run-time overlay, wherein the run-time node is generated using the executable node template such that the composition of the run-time node comprises the node instance and the executable node template.
6 . A method for storage management of run-time nodes of a template-based executable graph-based model, comprising: obtaining, by processing circuitry, a run-time node comprising a node template and a node instance generated according to the node template, wherein the node template is associated with a first unique node identifier and the node instance is associated with a second unique node identifier; extracting, by the processing circuitry, a node instance state from the node instance, wherein the node instance state comprises the first unique node identifier and the second unique node identifier; determining, by the processing circuitry, a storage location for the node instance state; generating, by the processing circuitry, a node instance manifest associated with the node instance, wherein the node instance manifest comprises the first unique node identifier, the second unique node identifier, and the storage location for the node instance state; generating, by the processing circuitry, a node instance manifest state for the node instance manifest, wherein the node instance manifest state comprises the first unique node identifier and the second unique node identifier; and storing, by the processing circuitry, the node instance manifest state.
7 . The method of claim 6 , wherein the node instance manifest state is stored at a first device and a node template manifest state associated with the node template is stored at a second device, the second device being different to the first device.
8 . The method of claim 6 , further comprising: storing, by the processing circuitry, the node instance state at the storage location.
9 . The method of claim 6 , further comprising: obtaining, by the processing circuitry, an executable node instance comprising the node instance and a first run-time overlay having an overlay instance comprising a third unique node identifier; extracting, by the processing circuitry, an executable node instance state from the executable node instance; determining, by the processing circuitry, a storage location for the executable node instance state; generating, by the processing circuitry, an executable node instance manifest comprising the second unique node identifier associated with the node instance, the third unique node identifier, and the storage location for the executable node instance state; generating, by the processing circuitry, an executable node instance manifest state for the executable node instance manifest, wherein the executable node instance manifest state comprises the second unique node identifier; and storing, by the processing circuitry, the executable node instance manifest state.
10 . The method of claim 9 , further comprising: storing, by the processing circuitry, the executable node instance state at the storage location for the executable node instance state.
11 . The method of claim 6 , further comprising: obtaining, by the processing circuitry, an executable node template comprising the node template and an overlay template comprising a fourth unique node identifier; extracting, by the processing circuitry, an executable node template state from the executable node template; determining, by the processing circuitry, a storage location for the executable node template state; generating, by the processing circuitry, an executable node template manifest comprising the first unique node identifier associated with the node template, the fourth unique node identifier, and the storage location for the executable node template state; generating, by the processing circuitry, an executable node template manifest state for the executable node template manifest, wherein the executable node template manifest state comprises the first unique node identifier; and storing, by the processing circuitry, the executable node template manifest state.
12 . The method of claim 11 , further comprising: storing, by the processing circuitry, the executable node template state at the storage location for the executable node template state.
13 . The method of claim 11 , wherein the executable node template manifest further comprises a fifth unique node identifier associated with an overlay instance generated from the overlay template.

Description

CROSS-REFERENCE TO RELATED APPLICATIONS The present application, filed on Oct. 28, 2024, is a continuation of U.S. patent application Ser. No. 18/229,607, filed on Aug. 2, 2023, which issued as U.S. Pat. No. 12,164,569 on Dec. 10, 2024, which claims priority under 35 U.S.C § 119 to U.S. Provisional Application No. 63/448,738, filed Feb. 28, 2023, and U.S. Provisional Application No. 63/442,682, filed Feb. 1, 2023, all of which are incorporated herein by reference in their entireties. TECHNICAL FIELD The present disclosure relates to executable graph-based models. Particularly, but not exclusively, the present disclosure relates to executable graph-based models which integrate data and data processing functionality. Particularly, but not exclusively, the present disclosure relates to template driven generation of executable graph-based models at run-time. BACKGROUND Modern system designs typically separate data storage from any functional data structure used from a processing logic perspective. This separation often occurs when data is “at rest” or at run-time where the processing system interacts with a copy of the relevant data in the processing space that can be of a different representation. This separation also leads to an impedance mismatch which requires some form of a data management solution to perform the necessary mappings between the two states. As a result of this separate of concerns, the processing logic is typically performed in a separate technology and physical tier (in an n-tier architecture) from the data. This is illustrated in the example n-tier architecture shown in FIG. 1. The example n-tier architecture 100 comprises a presentation layer 102, a processing logic layer 104, a data access layer 106, and a database layer 108. The presentation layer 102 comprises applications or components which are used to display the outputs of the processing logic layer 104 to a user or users. The processing logic layer 104 comprises applications, components, or services which perform some form of processing on the data obtained from the data access layer 106. The data access layer 106 comprises the applications, components, and/or services which can access the data used by the processing logic layer 104 and stored at the database layer 108. The database layer 108 handles the persistent storage of the data used by the system (e.g., in the form of a relational database, flat file, NoSQL database, graph database, and the like). The layers of the example n-tier architecture 100 are technically separated. Each layer may utilize a separate set of components to perform specific functionality (e.g., a database management system is used in the database layer 108 whilst an enterprise application is used in the processing logic layer 104). The layers of the n-tier architecture 100 may also be physically separated. For example, the database layer 108 may execute on a remote cloud service, the processing logic layer 104 may execute on a network within an enterprise, and the presentation layer 102 may execute on a user device within the enterprise. While some architectural designs require a clear separation of concerns between data and the use of the data, often the separation enforced by architectures such as that illustrated in FIG. 1 can severely inhibit the flexibility, extensibility, and responsiveness of any system created. Therefore, there is a need for enhanced architectures which provide improved flexibility, extensibility, and responsiveness thereby providing more efficient data processing systems. SUMMARY According to an aspect of the present disclosure, there is provided a method for template-driven generation of run-time executable graph-based models. The method comprises obtaining a node template comprising a predetermined node structure and one or more rules governing generation of node instances based on the node template. The method further comprises receiving, by the processing circuitry, one or more data elements and, in response to the one or more data elements being received, generating a first run-time node comprising the node template and a first node instance, wherein the first node instance comprises the one or more data elements mapped to the node template based on the one or more rules of the node template. The method further comprises obtaining a first run-time overlay comprising an overlay template and a first overlay instance comprising processing logic implementing at least one generic rule of the overlay template. The method further comprises generating a first executable run-time node comprising a composition of the first run-time node and the first run-time overlay such that the processing logic of the first run-time overlay is operable to interact with the first run-time node during execution of the first executable run-time node. According to a further aspect of the present disclosure, there is provided a method for loading run-time nodes of a template-based executable graph-base