Distributed digital rule processor for single system image on a clustered network and method

• US 6,154,765 A
• Filed: 03/18/1999
• Issued: 11/28/2000
• Est. Priority Date: 03/18/1998
• Status: Expired due to Term

• Current Assignee: Charles Jacob
• Original Assignee: Pasocs, LLC
• Inventors: Hart, Edward F.
• Primary Examiner(s): Geckil, Mehmet B.
• Application Number:
  US09/271,772
• Time in Patent Office: 621 Days
• Field of Search: 709/208, 709/201, 709/204, 709/209, 709/245, 709/249, 709/211, 370/409, 370/401, 712/28, 712/31, 712/35, 706/6, 706/15, 706/41, 706/42, 706/47, 706/916
• US Class Current: 709/201
• CPC Class Codes: G06F 9/44 Arrangements for executing specific programs
• CPC Class Codes: G06F 9/54 Interprogram communication
• CPC Class Codes: G06N 5/043 Distributed expert systems; Blackboards

Abstract

A distributed digital rule processor to create a single system image (SSI) on a cluster of von Neumann processors. The rule processing engine has a group of digital rule nets each having their own local bindery and local controllers which are interconnected by a global bindery. Slave translators are interfaced to the global bindery to receive rule calls from the rule nets and return statuses. A compiler maps the typical source code instructions into groups of rules which are stored in the rule nets'"'"' storage area. The rules contain groups of input variables and output variables. The output variables of a calling rule become the input and data for the called rule. Slave application processes on the von Neumann processors perform slave activities for the slave translators, as the rule nets are unable to manipulate data. Rules received from the rule nets by slave translators are processed and processed data or return statuses are sent back to the nets for further instructions. The rule nets contain the code compiled by the programmer and the application data is stored in the global buffers. This separates the code from data. The digital rules include node, processor, and thread addressing variables to permit extending the model to handle multiple nodes in a Wide Area Network, Local Area Network, System Area Network, or cluster.

Claims

1. A distributed digital rule processor to execute digital rules and create a single system image for a computer program on networked nodes having von Neumann processors comprising:

a plurality of rule nets each having an ordered list of rules, wherein each rule has inputs and outputs;

a plurality of slave translators to execute rules received from the rule nets and return the results and data from executed rules to a calling rule net;

wherein the rule nets can broadcast rules to other rule nets and slave translators based on the rules received from other rule nets;

a global controller coupled to the rule nets and slave translators, having a global bindery with a global data memory, a current rules'"'"' queue number, a function state and variables of the next rule to be broadcast to the rule nets and slave translators, and a current broadcast state, wherein the global data memory may only be accessed indirectly by the rule nets through the global controller and program data is only transferred from the global data memory when a rule is broadcast which requires the data, and program data is only updated in global data memory when it is received by a completed rule from a rule net;

a global rule distribution queue coupled to the global controller to store pending digital rules and sequentially broadcast rules to the rule nets and slave translators as signaled by the global controller; and

a plurality of local binderies in each rule net, wherein each local bindery has a function state wherein the function state and local binderies cannot be directly accessed by the rules in the rule net or global controller, and wherein the function state allows each rule net to rebroadcast a rule that failed to complete on the node to which the rule was broadcast to thereby allow the program to continue execution without the loss of gray data.

2. The distributed digital rule processor as in claim 1 wherein each rule net further comprises:

at least one local controller coupled to the plurality of local binderies and the global controller, to receive rules broadcast from other rule nets through the global controller and global queue wherein the rules are recognized and executed, and said local controller compares the received rules to the rules stored in a rule net storage to decide which rule to execute and broadcast next, and to generate other digital rules which will be broadcast to other rule nets and slave translators;

wherein the local controller stores the function state of the broadcast rules, local variables and the output variables for digital rules in the local binderies, and the function state can only be accessed by the local controller such that the local bindery cannot be corrupted by the rules in a rule net or the global controller.

3. The distributed digital rule processor as in claim 2 wherein each slave translator further comprises:

at least one slave local controller coupled to the global controller, to receive digital rules from the rule nets broadcast through the global controller and global queue that are recognized and executed, wherein said slave local controller compares the received digital rules to the rules stored in a slave translator storage to decide which rule to execute next and thereby generate a call to slave functionality to perform work on data passed with the rule; and

a slave local bindery coupled to each slave local controller to store the function state of the broadcast digital rules, local variables and the output variables for digital rules.

4. The distributed digital rule processor as in claim 3 wherein the slave local bindery coupled to each slave translator further comprises a plurality of local binderies coupled to each local slave controller, to store the state of multiple threads and handle recursion on each respective rule net and slave translator.

5. The distributed digital rule processor as in claim 1 further comprising a broadcasting means coupled to the global queue for broadcasting digital rules to the rule nets and slave translators.

6. The distributed digital rule processor as in claim 1 wherein the digital rules further comprise a conjunction of variables divided into groups of input variables and output variables wherein the rule outputs of a first rule are converted to the rule inputs for a second rule by the global controller and then stored in the global queue for broadcast.

7. A distributed digital rule processor as in claim 1 wherein a rule net will re-broadcast a rule which has not been accepted and completed by another rule net or slave translator.

8. The distributed digital rule processor as in claim 1 wherein the executing copies of the rule nets and slave translators are distributed across several nodes and backed up on at least one networked node.

9. The distributed digital rule processor as in claim 1 wherein the global controller is further comprised of a plurality of global controllers arranged in a hierarchical manner wherein each global controller directs a group of subordinate global controllers and divides the rules for several executing applications between the subordinate global controllers.

10. The distributed digital rule processor as in claim 1 wherein each rule net broadcasts rules on the global bindery and global queue, and waits a specified amount of time to receive an acknowledgment flag from the first rule net or slave translator who accepts the processing of the rule.

11. The distributed digital rule processor as in claim 1 wherein the global bindery broadcasts rules, global data, and receives rules to be stored in the queue.

12. The distributed digital rule processor as in claim 1 wherein the global digital rule distribution queue is a first in first out (FIFO) queue having a maximum number of rule storage positions equal to the number of rule nets in the network.

13. A distributed digital rule processor as in claim 1 further comprising a compiling means for converting programming instructions supplied by a programmer into digital rules which are stored in a rule nets'"'"' storage area.

14. The distributed digital rule processor as in claim 3 wherein the global controller, rule net local controllers and slave local controllers are each coupled to an individual von Neumann processor.

15. The distributed digital rule processor as in claim 3 wherein the global controller, rule net local controllers and slave translator local controller share a von Neuman processor.

16. The distributed digital rule processor as in claim 3 wherein the global controller further comprises a plurality of state storage buffers to store a queue number of a rule on the queue, a function state and input variables of the next rule to be broadcast to the rule net local controllers and slave nets, and a current broadcast state.

17. The distributed digital rule processor as in claim 3 wherein the local binderies and slave local binderies further comprise:

a function state buffer to define which group of parallel instructions may be recognized next for execution by the receiving rule net;

a counter overflow unit for storing an object number and the maximum time allowed to the slave translator and rule net to complete processing a rule before a failure is reported;

a rule parameter buffer for storing the parameters received with rule broadcasts from the global controller and global queue;

a from function number buffer to store a number defining the rule net which sent the current rule in the respective thread; and

a this node buffer to store the current chassis, and processor number to thereby identify the current rule net against other digital rules received by the rule net and in transmissions to the global controller, other rule nets and slave translators.

18. The distributed digital rule processor as in claim 3 which further comprises:

an Other_-- Node_-- Buffer coupled to each local controller and slave local controller to store a source or destination address for each broadcast rule wherein the address further comprises the network chassis and processor node address and wherein the Other_-- Node_-- Buffer is readable by the global controller.

19. The distributed digital rule processor as in claim 5 wherein the broadcasting means coupled to queue for broadcasting digital rules to the rule nets and slave translators further comprises a means for broadcasting a network addressing variable with each rule which can determine which one of the rule nets and slave translators will accept execution and processing of the broadcast rule.

20. The distributed digital rule processor as in claim 19 wherein the network addressing variable is able to address nodes selected from the group consisting of the Internet, a Wide Area Network, a Local Area Network, a networked cluster, and processors on a network cluster.

21. The distributed digital rule processor as in claim 6 wherein the digital rules further comprise digital parameters passed to the rule nets and slave translators to indicate constants and the location of data.

22. The distributed digital rule processor as in claim 2 wherein each local controller further comprises:

a plurality of dynamic global buffers for storing local data received from the global controller wherein said global buffers are visible to the slave translators.

24. The distributed digital rule processor of claim 22 wherein the global queue is a first in first out queue to receive and store rules received from rule nets which are then broadcast other rule nets and slave translators.

25. The distributed digital rule processor of claim 22 wherein the rule nets can call rules in other rule nets, and call rules in slave translators to perform processing on data.

23. A distributed digital rule processor to create a single system image and execute digital rules on networked von Neumann processors comprising:

a plurality of rule nets each having an ordered list of rules in a rule net storage, wherein each rule has inputs and outputs, the rule nets further comprising;

a local controller coupled to the rule net storage to recognize broadcast rules; and

a local bindery coupled to the local controller to store values, wherein the local bindery further comprises;

a function state buffer to define which group of parallel instructions may be recognized next for execution by the individual rule net;

a counter overflow unit for storing an object number and the maximum time allowed to a slave translator or rule net to complete the objects processing before a failure is reported;

a plurality of rule parameter buffers for storing the parameters broadcast by the global controller with a rule; and

a from function number buffer to store a number defining the rule net which sent a rule to a receiving rule net;

a global controller having a global queue, a global bindery to store the state of global queue, and global data, to thereby distribute digital rules and control the flow of digital information between the rule nets;

an Other Node Buffer to store return addresses of rules broadcast by the rule nets through the global controller and global bindery; and

a plurality of slave translators each having their own memory, operating system, object handler, and an asynchronous communication connection with the global controller and global bindery wherein the slave translators process rules and data received from the rule nets and return that processed data to the rule nets.

26. A method for distributed digital rule processing to execute digital rules and create a single system image for a computer program on networked nodes having von Neumann processors, the method comprising:

(a) compiling a plurality of rules;

(b) storing the rules in a plurality of rule nets;

(c) broadcasting a first digital rule from a global controller and a global queue;

(d) accepting the broadcast rule if it is recognized by a specific rule net or slave translator;

(e) updating a function state stored in one of a plurality of local binderies of the accepting rule net, wherein the function state and local bindery cannot be directly accessed by the rules in the rule net or the global controller;

(f) processing the digital rule when the rule is accepted by one of the rule nets;

(g) broadcasting a digital rule generated by the rule net as a result of the rule received by the rule net;

(h) updating a function state stored in one of a plurality of local binderies of the broadcasting rule net, wherein the function state stores a function state value of the rule broadcast;

(i) re-broadcasting a rule from a rule net which failed to complete on the node to which the rule was broadcast using the function state stored in the corresponding bindery, to thereby allow the program to continue execution without the loss of gray data;

(j) storing the broadcast rule in the global queue to be broadcast by the global controller to other rule nets and slave translators;

(k) accepting the broadcast rule when the rule is recognized by a specific rule net or slave translator;

(l) processing rules received by a slave translator by calling slave application program interfaces (APIs) having slave von Neuman processors to process the digital rule and return the results to the calling rule net; and

(m) repeating steps (d) through (l) until the processing of a distributed application is complete.

27. The method as in claim 26 wherein the step (d) of accepting the digital rule further comprises the steps of:

updating the counter overflow variable to store the amount of time allowed before the execution of the digital rule times out; and

checking one or more times to see if the execution of the digital rule has timed out.

28. The method as in claim 27 wherein the step of checking one or more times to see if the execution of the digital rule has timed out further comprises the step of setting the function state to an error handling state if the digital rule has not executed and times out.

29. The method as in claim 27 wherein step (g) of broadcasting a digital rule generated by the rule net as a result of the rule received by the rule net further comprises the step of broadcasting program data with the broadcast rule from a global data memory in the global controller wherein the global data memory may only be accessed indirectly by the rule nets through the global controller, and program data is only transferred from the global data memory when a rule is broadcast which requires the data, and program data is only updated in global data memory when it is received by a completed rule from a rule net.