Red Hat, Inc.

Mark Proctor

Edson Tirelli

Mario Fusco

Robert Kelley McWhirter

Luca Molteni

Roger Martinez Palleja

Michael Anstis

Kris Verlaenen

Aspects and features of the present disclosure can reconcile node sharing within a production rule network that is fully coded in a compiled language. As an example, the shared, stateless class can represent constraints shared by the alpha node of a rete network. Code can be post processed to create a shared stateless class defined in memory. When the rule engine is executed and the rule network is produced, the shared stateless class can be referenced to evaluate a constraint shared by a node of the production rule network, reducing the number of classes stored in memory. Garbage collection can be used within the shared stateless class, deleting objects from memory structure when no longer used, further improving storage efficiency.

Node sharing for a rule engine coded in a compiled language

Methods, systems, and computing systems are provided for providing a visual representation of a domain model. An example method includes providing a class corresponding to a first stencil. The class is annotated to include a definition, a property, and a rule. A visual representation of the first stencil is provided in a graphical user interface, where the annotated definition and the annotated property modify the visual representation that is displayed. When the visual representation is moved, by a user, in relation to a second stencil, a determination is made, based on the location of the moved first stencil and the second stencil, that the first stencil violates the rule. The visual representation of the moved first stencil is modified to indicate the violation of the rule.

Framework for modeling with domain model capabilities

Systems and methods for allowing pluggable knowledge types to be discovered, registered, and added to a rule engine are disclosed. An example method may include retrieving, by a processing device executing a rule engine, a list of pluggable services associated with a specified knowledge type; identifying a first pluggable service on the list of pluggable services; identifying one or more knowledge types that the first pluggable service is configured to process, wherein the one or more knowledge types comprise the specified knowledge type; and indexing, by the processing device, the first pluggable knowledge in the service registry by information identifying the one or more knowledge types.

Pluggable knowledge types in a rule engine

A processing device executes a multi-threaded rule engine having multiple threads. A first thread is associated with user interactions. A second thread is associated with timing events. A third thread is associated with asynchronous execution of the rule engine. A rule engine core is accessible to the second and third threads. The processing device receives user input and generates a first command to perform a first action in view of the user input while executing the first thread. The processing device stores the first command in a queue where the first command is one of multiple commands stored in the queue. The processing device retrieves the multiple commands from the queue and processes the multiple commands using the rule engine core while executing the third thread. The rule engine core is inaccessible to the second thread while in use by the third thread.

Thread coordination in a rule engine using a state machine

A processing device executing a rule engine receives a first object. The processing device determines whether the first object is represented by a relational model or an object-oriented model. The first object is determined to be represented by the relational model responsive to the first object lacking a reference to a nested object. The first object is determined to be represented by the object-oriented model responsive to the first object including a reference to a nested object. If the first object is represented by the relational model, a join is performed between the first object and a second object based on a relationship between the objects using a first node. If the first object is represented by the object-oriented model, an expression of the first object is evaluated to navigate to a third object that is a first nested object of the first object using a second node.

Building a hybrid reactive rule engine for relational and graph reasoning

Disclosed herein are systems, methods, and non-transitory computer-readable storage media for managing spreadsheets with decision tables. The exemplary method includes generating an underlying data model associated with a visual data model of a spreadsheet containing a decision table, populating the underlying data model based on information contained in the visual data model and based on the decision table, generating a first index for mapping cells in the visual data model to cells in the underlying data model consistent with the decision table, and generating a second index for mapping cells in the underlying data model to cells in the visual data model consistent with the decision table.

Tabular widget with mergable cells

Some embodiments of efficient binary protocol marshalling for rule engine sessions have been presented. In one embodiment, a set of marshalling plug-ins is provided to a rule engine. Each of the set of marshalling plug-ins is customized for a type of user objects. In response to encountering a user object, the rule engine selects a marshalling plug-in out of the set of marshalling plug-ins based on a type of the user object to marshall in or to marshall out the user object.

Efficient binary protocol marshalling for rule engine sessions

A processing device executing a Rete rule engine modifies a particular property of an object that has traversed a Rete network. The processing device associates a first data structure with the object, the first data structure indicating that the particular property of the object has been modified. The processing device then determines whether the particular property is a constraint relevant to a node of the Rete network based on comparing the first data structure to a second data structure associated with the node, wherein the second data structure identifies one or more modifiable properties that are constraints relevant to the node. If the particular property is a constraint relevant to the node, the processing device evaluates the object with the node. If the particular property is not a constraint relevant to the node, the processing device determines not to evaluate the object with the node.

Property reactive modifications in a rete network

Some embodiments of pattern behavior support in a rule engine have been presented. In one embodiment, a behavior builder registry is stored on a computer-readable storage device in a server. The behavior builder registry includes a set of behaviors supported by a rule engine and a set of builders associated with the behaviors. A compiler running on the server may compile a set of rules using the behavior builder registry to generate a network having a set of nodes. In response to a data object asserted propagating into a node of the network, the rule engine may first check one or more behaviors at the node before applying one or more regular constraints at the node on the data object asserted.

Pattern behavior support in a rule engine

Some embodiments of using left and right unlinking by an example rule engine have been presented. A rule engine can create a network having a number of nodes to evaluate a set of rules in a knowledge base. The rule engine may initialize a session to be processed using the network to allow each of the nodes to be logically left unlinked and logically right unlinked at the same time during the session.

Using left and right unlinking

Some embodiments of a simulation and test framework for a rule engine have been presented. In one embodiment, a simulator runs a simulation in a time-aware environment. A rule engine, coupled to the simulator, may execute a set of business logic in response to the simulation in order to test behavior of the business logic. The business logic may include rules, workflow, and event processing.

Simulation and test framework for a rule engine

A method to support multi-dimensional tuples in rule engines having rule engine executed by a processing device can evaluate facts in a working memory stored on a data storage device against a rule with repetitions. The rule engine may create a multi-dimensional tuple to hold a set of the facts that matches the rule. The multi-dimensional tuple has a set of elements and an index for each of the elements. Each element of the multi-dimensional tuple is a single fact or a tree structure for holding a set of facts of a repetition group that matches the rule with repetitions.

Multi-dimensional tuple support in rule engines

Some embodiments of knowledgebase partitioning for implementing parallelization in a rule engine have been presented. In one embodiment, a compiler divides a knowledgebase into a set of virtual partitions. The knowledgebase includes a network constructed according to rules added to the knowledgebase. A rule engine may execute the virtual partitions of the partitioned knowledgebase in parallel using threads obtained from a pool of threads.

Knowledgebase partitioning

Some embodiments of implementing left and right unlinking for a shared knowledge base in an exemplary rule engine have been presented. A rule engine can create a network to evaluate a set of rules in a knowledge base. The network includes at least one multiple-input node, such as a beta node having two inputs. The rule engine may process data in multiple sessions simultaneously using the network. The rule engine may further logically unlink a first node in the network from a second node in the network for a first session while keeping the first node linked to the second node for a second session.

Left and right unlinking for a shared knowledge base

Some embodiments of a method to reduce churn caused by excessive linking and unlinking have been presented. A rule engine can create a network having a number of nodes to evaluate a set of rules in a knowledge base. The rule engine may unlink a node in the network in response to an input of the node becoming empty in a session. The rule engine may then wait a predetermined period of time before allowing the node to be unlinked again during the session.

Growing community of inventors

London, United Kingdom

Mark Proctor