398 TIMING ANALYSIS OF PREDICATE-LOGIC RULE-BASED SYSTEMS
as the value of attribute attri will be assigned as a data item of attribute attri. For example, in the following rule
(p p1
(a ^a1 A ^a2 <x>) (a ^a1 B ^a2 <x>)
-->
(make b ^b1 C ^b2 D) (modify 1 ^a1 C))
A, B, and C are assigned as the data items of attribute a1^ because they appear as
the values of this attribute. C is also assigned to the data items of attribute ^ . D is b1
assigned to attribute ^ . b2
If the number of data items is less than the input number, the tool generates arbitrary constants as the remaining data items. For example, if we input five data items of attribute a1^ in class a, then we have three items in a1^ ’s domain. The other two items are arbitrarily generated as &a1-1 and &a1-2. These arbitrary constants do not affect the timing properties since they only match LHS variables. All LHS constant data items can be generated from the previous search.
The user’s negative condition elements are given in a separate file, file.usr. The Backus-Naur Form (BNF) description of the negative condition elements and variable range is given below.
neg-cond-elements ::= -( classname attributes-values )
attributes-values |
::= ↑attribute op value |↑attribute value |
op |
::= = | |
value |
::= variable | constant |
variable-range |
::= variable constant+ # |
Several terms have been left undefined. classname and attribute must be defined in the declaration of the original program. variable, defined in variable-range, must be defined in value. neg-cond-elements specifies the negative condition elements. variable-range specifies the boundary of variables.
Three files are generated by this tool: file.WM, file.All, and filetest.ops. File file.WM contains the set of initial WMEs that is the union of all LHS condition elements. File file.All contains all possible WMEs in the data domain. Neither file includes the WMEs satisfying the user’s negative condition elements. The set of WMEs in file.All causes maximum matching time and should also cause maximum rule firings. Users can modify file.WM and file.All to remove unnecessary WMEs or rearrange the order of these WMEs. File filetest.ops is the test program, which eliminates the negative condition elements and modifies corresponding condition numbers on the RHS of rules.
Industrial Example: Experiments on the OMS OPS5 Program No data are given in oms.dom, so the tool searches possible data items from the semantics
400 TIMING ANALYSIS OF PREDICATE-LOGIC RULE-BASED SYSTEMS
this problem in the context of OPS5 production systems. Two aspects of the response time of a program are considered, the maximal number of rule firings and the maximal number of basic comparisons made by the Rete network during the execution of the program.
The response-time analysis problem is in general undecidable. However, a program terminates in a finite time if the rule triggering pattern of this program satisfies certain conditions. Here we present four such termination conditions for OPS5 production systems. An algorithm for computing an upper bound on the number of rule firings is then given. To have a better idea of the time required during execution, we present an algorithm that computes the maximal time required during the match phase in terms of the number of comparisons made by the Rete network. This measurement is sufficient since the match phase consumes about 90% of the execution time.
11.3.1 Introduction
Although the response-time analysis problem is in general undecidable, we observe that, through appropriate classification, several classes of production systems exist for which the property of termination is guaranteed. Each of these classes of production systems is characterized by an execution termination condition. Hence, we tackle the response-time analysis problem by first determining whether the given system is in one of the classes with the property of execution termination and then computing an upper bound on the maximal response time, if possible.
A graph, called the potential instantiation graph, showing the potential rule triggering patterns, is defined to be used as the basis to classify OPS5 programs. We show that a program always terminates in a bounded number of recognize–act cycles if its potential instantiation graph is acyclic. An algorithm, Algorithm A, used to compute an upper bound on the number of recognize–act cycles during program execution is then given. This algorithm also computes the respective maximal numbers of working memory elements that may match the individual condition elements of rules during the execution of a program. These numbers are crucial in determining the time required in the match phase during the execution. We present an algorithm, Algorithm M, to utilize these numbers to compute the maximal number of comparisons made by the Rete network in the match phase, since it is well known that the match phase consumes about 90% of the execution time [Ishida, 1994]. Furthermore, several classes of programs with cyclic potential instantiation graphs have been found to also have bounded response times. We will show how we can apply these algorithms to programs in one of these acyclic classes.
On the other hand, the response time of programs with cyclic potential rule firing patterns usually depends on the value of run-time data, which cannot be known in advance. It is not realistic to try to develop an algorithm to predict the response time upper bounds of a program with cyclic potential rule firing patterns. Determining whether a given program with cyclic potential rule firing patterns always terminates is the most we can do at this time.
CHENG–CHEN TIMING ANALYSIS METHODOLOGY |
401 |
The property of termination of a given program depends on whether all of its potential rule firing cycles terminate. Due to the lack of run-time information that is crucial in determining the satisfiability of condition elements, a conservative approach has to be taken in static analysis to determine whether a condition element can be satisfied by a working memory element whose value/content cannot be known in advance. The potential instantiation graph produced as a result of the static analysis usually contains many edges that are nonexistent. This in turn means that many cycles found in the potential instantiation graph are nonexistent. With the help of the programmer, some of these nonexistent edges/cycles can be detected and removed from the potential instantiation graph. We will discuss later how the programmer can help improve/adjust the potential instantiation graph.
When knowledge-based or production systems are used in time-critical applications, it is essential to predict, prior to their execution, their worst-case response time during actual execution. This static timing analysis problem is extremely difficult even for propositional-logic-based rule-based systems such as EQL [Cheng et al., 1993]. For predicate-logic-based rule-based systems such as those implemented in OPS5 and OPS5-style languages, very few practical static analysis approaches are available. Together with the Cheng–Tsai approach, this approach thus makes a significant contribution to the state-of-the-art for solving this static timing analysis problem by presenting a formal framework and a useful tool set for worst-case response-time prediction of a class of OPS5 and OPS5-style production systems. The proposed analysis techniques are based on (1) the detection of termination conditions, which can be checked by a semantic analysis of the relationships among rules in a rulebase, and (2) the systematic trace of tokens in the match network. These techniques are more efficient than those that rely on longest-path analysis in a state-transition system corresponding to a given rule-based system.
The remainder of this section is organized as follows. We first define the potential instantiation graph and then classify OPS5 programs using this graph. Then we present the response-time analysis of the OPS5 production systems. We first show the property of termination of programs with acyclic potential instantiation graphs. Two algorithms to compute the response time of OPS5 production systems of this class are then introduced. Next, the programs with cyclic potential instantiation graphs are investigated. We show how we can apply the proposed algorithms to one class of programs with cyclic potential instantiation graphs. Then two more cyclic classes of programs with the property of termination will also be introduced. Finally, we describe the experimental results.
11.3.2 Classification of OPS5 Programs
Let r1 and r2 denote two OPS5 rules, A denote an action in the RHS of r1, and e denote a condition element in the LHS of r2. Action A matches the condition element e if the execution of A produces/removes a WME that matches e. Based on the types of A and e, four cases exist in which A matches e.
402 TIMING ANALYSIS OF PREDICATE-LOGIC RULE-BASED SYSTEMS
M1 The execution of A produces a WME that matches the nonnegated condition element e. In this case, r2 may be instantiated as a result of the firing of r1.
M2 The execution of A produces a WME that matches the negated condition element e. If this is the case, the system will be in a state where r2 cannot be instantiated immediately after the firing of r1.
M3 The execution of A removes a WME that matches the nonnegated condition element e. In this case, r2 may still be instantiated after the firing of r1 if there are more than one WME matching e before the firing. On the other hand, if r2 is not instantiated before the firing of r1, it cannot be instantiated immediately after the firing of r1.
M4 The execution of A removes a WME that matches the negated condition element e. In this case, r2 may be instantiated as a result of the firing of r1.
r1 is said to dis-instantiate r2 if no instantiation of r2 exists at each state reached as a result of the firing of r1. Of the four cases above, only case M2 guarantees that r2 cannot be instantiated as a result of the firing of r1. Hence, r1 dis-instantiates r2 if and only if the RHS of r1 contains an action that produces a WME matching a negated condition element in the LHS of r2. r1 is said to potentially instantiate r2 if an instantiation of r2 exists as a result of a firing of r1. Hence, r1 potentially instantiates r2 if case M2 does not occur and either M1 or M4 occurs. That is,
•the RHS of r1 does not contain an action that produces a WME matching a negated condition element in the LHS of r2, and
•the RHS of r1 contains an action that either produces a WME matching a nonnegated condition element of r2 or removes a WME matching a negated condition element in the LHS of r2.
Definition 6 (Potential Instantiation graph). Let p denote a set of production rules. The potential instantiation (PI) graph, G Pp I = (V, E), is a directed graph demonstrating the potential rule-triggering pattern of p. V is a set of vertices, each of which represents a rule such that V contains a vertex labeled r if and only if a rule named r is in p. E is a set of directed edges such that E contains the edge r1, r2 if and only if the rule r1 potentially instantiates the rule r2.
Definition 7 (Cycle classification). Let r1, r2 denote an edge in G Pp I . The edge r1, r2 is classified as a
•p(ositive)-type edge if r1 does not contain an action that removes a WME matching a negated condition element of r2,
•n(egative)-type edge if r1 does not contain an action that produces a WME matching a nonnegated condition element of r2, or
•m(ixed)-type edge if it is neither a p-type edge nor an n-type edge.
A path is denoted as ri , ri+1, . . . , rk , where r j , r j+1 G Pp I and j = i . . .
k − 1. A cycle is a path ri , ri+1, . . . , rk and ri = rk . A cycle C G Pp I is an n-type
|
CHENG–CHEN TIMING ANALYSIS METHODOLOGY |
403 |
||
|
cycles |
|
|
|
n − type cycles |
p − type cycles |
m − type cycles |
|
|
n − type edge |
n − type edge |
p − type edge |
p − type edge |
|
only |
& |
only |
& |
|
|
m− type edge |
|
m − type edge |
|
n− type edge |
|
|
|
|
& |
n − type edge |
|
m − type edge |
|
p− type edge |
& |
|
only |
|
|
m − type edge |
|
|
|
|
& |
|
|
|
|
p − type edge |
|
|
|
Figure 11.6 PI graph cycle classification.
cycle if it contains an n-type edge, a p-type cycle if it contains only p-type edges or an m-type cycle if it is neither an n-type cycle nor a p-type cycle, as shown in Figure 11.6.
Example 14. Consider the following three cases, each of which represents a different edge type.
Case 1: |
(P r1 (E1 · · ·) (E2 · · ·) |
−→ (make E3 |
↑name N1 ↑state good) |
||
|
(remove 1)) |
|
−→ |
(· · ·) (· · ·) ) |
|
|
(P r2 (E2 · · ·) (E3 ↑state good) |
||||
|
r1 does not contain an action that produces a WME matching a negated |
||||
|
condition element of r2. Furthermore, the firing of r1 produces a WME |
||||
|
of the class E3 that matches one of the nonnegated condition elements |
||||
|
of r2, and r1 does not contain an action that removes a WME matching |
||||
|
a negated condition element of r2. Hence, r1 potentially instantiates r2. |
||||
|
G Pp I contains the p-type edge r1, r2 . |
(make E3 · · ·) (modify E2 · · ·) |
|||
Case 2: |
(P r3 (E1 ↑dept Math)(E2 · · ·) −→ |
||||
|
(remove 1)) |
|
|
(· · ·) (· · ·)) |
|
|
(P r4 (E4 · · ·) –(E1 ↑dept Math) −→ |
||||
|
The firing of r3 produces a WME of the class E3 that does not match |
||||
|
the nonnegated condition element E4 of r4. Furthermore, r3 contains a |
||||
|
modify action that deletes the old WME E2 and produces the new WME |
||||
|
E2 and does not match a nonnegated condition element E4 of r4. So, the |
||||
|
edge r3, r4 is an n-type edge. |
(make E3 |
↑name N1↑state good) |
||
Case 3: |
(P r5 (E1 ↑dept Math) |
−→ |
|||
|
(remove 1)) |
|
|
|
|
|
(P r6 (E2 · · ·) –(E1 ↑dept Math)(E3 ↑state good) −→ (· · ·) (· · ·)) |
||||
404 TIMING ANALYSIS OF PREDICATE-LOGIC RULE-BASED SYSTEMS
Since r5 contains a remove action that removes E1 matching a negated condition element E1 of r6, and contains a make action that produces E3, matching a nonnegated condition element E3 of r6, it is neither a p-type edge nor an n-type edge. Therefore, the edge r5, r6 is an m-type edge.
Example 15. We show how to construct the PI graph of a program segment of the Waltz.
1. Program segment Waltz as follows:
(P r1 (stage ↑value duplicate) (line ↑p1 p1 ↑p2 p2 ) −→ ( make edge ↑p1 p1 ↑p2 p2 ↑jointed false) ( make edge ↑p1 p2 ↑p2 p1 ↑jointed false) ( remove 2))
(P r2 (stage ↑value duplicate) –(line) −→ ( modify 1 ↑value detect junctions))
(P r3 (stage ↑value detect junctions) (edge ↑p1 base point ↑p2 p1 ↑jointed false) (edge ↑p1
base point ↑p2 {p2 p1} ↑jointed false) (edge ↑p1 base point ↑p2 {p3 p1 p2} ↑jointed false) −→ ( make junction ↑type arrow ↑base point base point ) ( modify 2 ↑jointed true) ( modify 3 ↑jointed true) ( modify 4 ↑jointed true))
(P r4 (stage ↑value detect junctions) (edge ↑p1 base point ↑p2 p1 ↑jointed false) (edge ↑p1base point ↑p2 {p2 p1} ↑jointed false) –(edge ↑p1 base point ↑p2 { p1 p2})
−→ ( make junction ↑type L ↑base point base point ↑p1 p1 ↑p2 p2 ) ( modify 2 ↑jointed true) ( modify 3 ↑jointed true))
(P r5 (stage ↑value detect junctions) – (edge ↑jointed false)
−→ ( modify 1 ↑value find initial boundary))
(P r6 (stage ↑value find initial boundary) (junction ↑type L ↑base point base point ↑p1 p1 ↑p2 p2 ) (edge ↑p1 base point ↑p2 p1 ↑label nil) (edge ↑p1 base point ↑p2 p2 ↑label nil) –(junction ↑base point > base point ) −→ ( modify 3 ↑label B) ( modify 4 ↑label B) ( modify 1 ↑value find second boundary))
(P r7 (stage ↑value find initial boundary) (junction ↑type arrow ↑base point bp ↑p1 p1 ↑p2
p2 ↑p3 p3 ) (edge ↑p1 bp ↑p2 p1 ↑label nil) (edge ↑p1 bp ↑p2 p2 ↑label nil) (edge
↑p1 bp ↑p2 p3 ↑label nil) –(junction ↑base point > bp ) −→ ( modify 3 ↑label B) ( modify 4 ↑label plus) ( modify 5 ↑label B) ( modify 1 ↑value find second boundary))
(P r8 (stage ↑value find second boundary) (junction ↑type L ↑base point base point ↑p1 p1 ↑p2 p2 ) (edge ↑p1 base point ↑p2 p1 ↑label nil) (edge ↑p1 base point ↑p2 p2 ↑label nil) –(junction ↑base point < base point ) −→ ( modify 3 ↑label B) ( modify 4 ↑label B) ( modify 1 ↑value labeling))
(P r9 (stage ↑value find second boundary) (junction ↑type arrow ↑base point bp ↑p1 p1 ↑p2
p2 ↑p3 p3 ) (edge ↑p1 bp ↑p2 p1 ↑label nil) (edge ↑p1 bp ↑p2 p2 ↑label nil) (edge
↑p1 b ↑p2 p3 ↑label nil) –(junction ↑base point < bp ) −→ ( modify 3 ↑label B) ( modify
4 ↑label plus) ( modify 5 ↑label B) ( modify 1 ↑value labeling))
(P r10 (stage ↑value labeling) (edge ↑p1 p1 ↑p2 p2 ↑label {label plus minus B} ↑plotted nil) (edge ↑p1 p2 ↑p2 p1 ↑label nil ↑plotted nil) −→ ( modify 2 ↑plotted t) ( modify 3
↑label label ↑plotted t))
2.We translate these rules into a potential instantiation graph based on definition 6 and definition 7.