Abstract:
The control data locking protocol allows a concurrency control manager and data store to permit concurrent dynamic access between those creating or modifying control data and those using the data in their execution sessions. The invention applies to the use of production rules in inferencing sessions or to the use of ordered processing of flow rules by a workflow manager. The invention grants inference locks, read locks and write locks. Pre-lock notification with negotiation is implemented. Post-lock notification is also implemented. Those who are using the rules and those who are modifying them can specify whether changes should be incorporated immediately. In case two requested locks conflict, users resolve the conflict before both are granted. Controlled invocation of conversion processing converts session data as necessary to allow changes in control data to be made while the control data is being used in existing execution sessions.

Description:
BACKGROUND OF THE INVENTION 
     1. Field of the Invention 
     This invention relates to apparatus and methods for supporting concurrent dynamic access to control data. The present invention is particularly useful in expert systems for supporting concurrent dynamic access between those program users creating or modifying production rules, and those users executing them in inferencing sessions. The invention is also useful in the context of ordered rule processing systems, such as workflow managers. Again, there needs to be dynamic, concurrent access by those users changing the rules and those users using them to control their execution flow. 
     2. Description of the Prior Art 
     Concurrent access is becoming increasingly important as expert system applications are used in changing manufacturing environments and machine learning applications. Prior systems for controlling access to control data have not permitted concurrent access. For example, prior systems have not permitted a user to modify a production rule and have the change be reflected in currently executing inferencing sessions. 
     Production rules are one form of representing knowledge for use by an expert system shell. Each production rule has an IF part and a THEN part. The IF part consists of a set of conditions which must be satisfied for the rule to be eligible to fire. The THEN part of a production rule consists of a series of actions to take if the rule is fired. To fire a rule means to execute it by performing the actions found in the THEN part. 
     Inferencing is the logical chaining affect that occurs when production rules are fired; i.e., executed. In forward chaining, the shell identifies a rule whose IF part is true and fires the actions in the THEN part. These executed actions may cause the IF parts of other rules to become true, and those rules are selected and fired. Backward chaining starts with a goal, and finds rules whose THEN part makes the goal true. One of these rules is selected and the conditions of its IF part become the goals to be met. For example, if the original goal was A=1, the system might select a rule which says IF B=2 and C=3, THEN A=1. The new goals to be met are B=2 and C=3. In an inferencing session, forward and backward chaining continues until the problem is solved or no further progress can be made. 
     Prior art database management systems include U.S. Pat. No. 5,065,400. This patent describes a method for utilizing a table to track whether programs which contained errors have been corrected. It tracks logically-related programs to ensure they have been properly corrected prior to recompiling. This patent assumes that only the most current version of a program will be used, and does not allow controlled use of old rules through notification and response, multiple versions and conversion actions. 
     U.S. Pat. No. 5,005,119 describes a method for permitting users to control the execution of a series of programs and what data is inputted into, and created by, that execution. It allows controlled testing of different versions of programs. However, it does not allow controlled cooperation between those program users who are changing rules and those users executing them, nor can it specify that changes take effect immediately or be delayed. 
     U.S. Pat. No. 4,805,106 describes a method to coordinate replicated computer memories across a network. Serial access is enforced, and any updates are done to all copies. Multiple copies are not allowed. 
     U.S. Pat. No. 4,809,170 describes a method for tracking updates to computer software as it is developed. A current version is established, and a delta file of updates is kept. Notification is used to inform different users that they may be changing the same program, but it does not delay updates until possible conflicts are resolved. 
     U.S. Pat. No. 4,709,326 describes a method of implementing a locking device in either hardware or software. The protocol matrix is mapped to a bit transition table. Bits also record what devices must be notified of lock changes. This patent does not include notify and respond processing, and users cannot control whether a lock is granted. It does not address cooperation between updating and executing sessions. 
     U.S. Pat. No. 4,558,413 describes a system to track the development of computer programs and bring versions together for compiles. Notification is used to inform the controller that a program has been changed. This patent is directed at controlling a build, not managing execution and modification concurrently. 
     Two published papers also attempt to address the problem of concurrent access to control data in an inferencing environment. &#34;Concurrency Control in Advanced Database Applications&#34;, by N. Barghouti, Published in ACM Computing Surveys, Volume 23, No. 3, September, 1991, illustrates the use of multiple versions and early and late notification for maintaining control data. It does not include negotiation of whether or not locks should be allowed, or requirements between those changing and executing the control data. &#34;A Mechanism for Concurrency Control in a Coupled Knowledge Base Management System&#34; by Y. Chen et al discusses the need for locking working memory data, but uses serial protocol to control access rather than allowing multiple versions and using conversion processing. 
     Regarding ordered rule processing, current projects allow definition of processes using various syntaxes, such as procedural rules or flow networks. These systems track states of execution instances. However, changes to the process definitions affect only new execution instances. Changes to individual instances require the instance execute from a copy of process flow. Again, concurrent, dynamic access by those updating and those executing the same control data is not supported. One related paper is &#34;CIM-OSA and Stochastic Time Petri Nets for Behavioral Modelling and Model Handling in CIM Systems Design and Building&#34; by M. Aguilar et al and published in Proceedings of the Institute of Mechanical Engineers, Part B (Journal of Engineering Manufacture), Volume 207, Number B3, 1993. This paper reviews a type of ordered rule processing, but assumes a serial process for moving the rules to an execution environment. 
     A need remains in the art for a method of managing execution and modification concurrently. 
     SUMMARY OF THE INVENTION 
     It is an object of this invention to support concurrent access to execute, or modify, control data by granting or denying locks on the data requested by various programs. 
     In accordance with the present invention, the first program to request a lock of any type on a section of control data is granted the lock. A section of control data might be a rule, or set of rules, in an expert system inferencing session or ordered rule processing session. One example of ordered rule processing session is a process execution controlled by a workflow manager. When another program requests a lock on the same section of control data, the second lock is granted if the two locks do not conflict and denied if the two locks conflict. As a feature of the present invention, both programs are notified of the situation if the two locks do conflict but, under the circumstances, it is likely that one or the other of the two users would be willing to change the lock held or requested so that the request could be accommodated. The users are permitted to negotiate the two locks. The negotiation is successful and the second lock is granted if the lock holder gives up the lock or changes it to a type which does not conflict, or the requester changes the type of lock requested to a type which does not conflict. 
     Three types of locks are provided: Executing (termed an &#34;inferencing lock&#34; in the figures and detailed description), reading, and writing. For the purpose of determining conflicts between lock requests, each type of lock is categorized into one of two categories in a total set of four categories: Immediate, delayed, shared and updating. Executing and writing locks may be categorized as immediate or delayed. Reading locks may be categorized as shared or updating. 
     The locks conflict if the lock is a writing lock and the request is for a writing lock. The request from the second program does not conflict if the lock is an executing lock and the request is an executing lock, the lock is an executing lock and the request is for a reading shared lock, the lock is a reading shared lock and the request is for an executing lock or a reading shared lock, the lock is a reading update lock and the request is for an executing lock, the lock is a writing immediate lock and the request is for an executing immediate lock, or the lock is a writing delayed lock and the request is for an executing delayed lock. The request from the second program is negotiable if the lock is an executing lock and the request is for a reading update lock or a writing lock, the lock is a reading shared lock and the request is for a reading update lock or a writing lock, the lock is a reading update lock and the request is for a reading lock or a writing lock, the lock is a writing immediate lock and the request is for an executing delayed lock or a reading lock, or the lock is for a writing delayed lock and the request is for an executing immediate lock or a reading lock. 
     As another feature of the invention, a lock holder program may request late notify, which informs the program when another lock has been granted on that section of control data. A lock holder or requestor program may alternatively request early notification, before a lock is granted, when possible conflicts exist with other lock holders. 
     In one embodiment of the invention, an inferencing program may hold an executing lock on a section of control data which is a rule which may be fired or expanded. In another embodiment of the invention, an executing lock may be held by a sequential rule processing program which executes a series of rules which comprise the sections of control data. As a feature of the present invention, conversion processing makes necessary adjustments to control and non-control data to allow immediate use of a modified rule by an inferencing or sequential rule processing session. 
     Those having normal skill in the art will recognize the foregoing and other objects, features, advantages and applications of the present invention from the following more detailed description of the preferred embodiments as illustrated in the accompanying drawings. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     FIG. 1 is a block diagram showing the communication between the Concurrency Control Manager and Data Store (CCMDS) and inferencing and updating sessions. 
     FIGS. 2A, 2B is a flowchart showing the interaction between execution of the inference engine and the Concurrency Control Manager and Data Store. 
     FIG. 3 is a flowchart showing the interaction between modification or update request and the Concurrency Control Manager and Data Store. 
     FIGS. 4A and 4B show flowcharts of the process and operation of freeing a lock and the process and operation of committing an update, respectively. 
     FIG. 5 is a flowchart showing the process and operation of requesting a rule lock. 
     FIGS. 6A, 6B, 6C is a flowchart showing the process and operation of requesting an inference lock. 
     FIGS. 7A-7E is a flowchart showing the process and operation of requesting a rule read lock. 
     FIGS. 8A-8D is a flowchart showing the process and operation of requesting a rule write lock. 
     FIGS. 9A-9D show locking protocol matrices for rules (FIG. 9A) and for rules and data (FIG. 9B). 
     FIG. 10 is a table of terms. 
     FIGS. 11A, 11B is a block diagram showing the communication between the Concurrency Control Manager and Data Store (CCMDS) and an ordered rule processor, such as a workflow manager. 
    
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS 
     FIG. 1 is a block diagram showing the interaction between the Concurrency Control Manager and Data Store (CCMDS) 11, inferencing sessions 12 and 13, and updating sessions 14 and 15. As an overview, when a user starts an inferencing session 12, the session signals to the CCMDS 11 first that inferencing will take place, second which rules will be used by the session, and third whether the session wishes any changes made by others to those rules to be incorporated immediately in the inference session. This represents the start of an inference transaction, meaning the control data is currently being processed as an instance of an execution for this session. The CCMDS determines whether any conflicts exist in accordance with the inferencing locking protocol matrix in FIG. 9A as described later herein. 
     When conflicts exist between a inferencing session that has a lock and one or more sessions requesting a lock, the CCMDS arranges for the sessions to immediately negotiate and resolve the conflicts, if possible. If the necessary inferencing locks can be granted to a requesting session, inferencing proceeds as shown and described in detail in FIG. 2. Whenever inferencing session 12 needs to use a specific rule, the CCMDS attempts to get a shared read lock on the rule, as discussed in reference to FIG. 9. A read lock is requested because the inferencing session will be using the rule and wants to know whether anyone intends to modify it. A shared read lock is requested because the session has no intent to update, or modify, the rule. Therefore, anyone else is free to use it. The CCMDS initiates necessary conversion processing of control and non-control data as inferencing proceeds. When inferencing completes, all inferencing locks are released. This represents the end of the inference transaction, established when the execution instance was started. 
     Similarly, when a user starts an updating session 14, the session signals the CCMDS. CCMDS 11 attempts to get a read update lock on the rule to be modified, while managing conflicts per the locking protocol matrix in FIG. 9A. When the modification is complete, the update session requests the update to be immediately visible to existing inference sessions, or delayed until existing inferencing sessions complete. The CCMDS attempts to get the requested lock, makes the update, initiates conversion processing of control and non-control data necessitated by the changes, and frees the lock since it is now finished. FIG. 3 shows this process in more detail, and is described hereinafter. 
     FIG. 2 shows in more detail the interaction between the inferencing process 14 and the database management control system (CCMDS) 11 in the preferred embodiment of the present invention. The inferencing process begins at operation 20, and step 22 signals an inference session to the CCMDS 11. The CCMDS, in operation 24, requests any necessary inference rule locks, which notify other sessions: First, that the rule is being used by the inferencing session, and second, whether updates should take effect immediately. 
     I --  RL --  I (&#34;inference rule immediate&#34;) indicates that the inferencing session requests immediate updating of rules. In other words, updates of rules by others are to be incorporated immediately during the active inferencing session. I --  RL --  D (&#34;inference rule delayed&#34;) indicates that updates are to be delayed until a new inferencing session starts. 
     The CCMDS at step 26 executes any presession conversion required for the locked rules. Conversion processing is the activity that needs to be taken to allow continued inferencing when a rule is changed while it is being used in an inferencing session. For example, the old version of a rule may have had an IF part checking for a value of &#34;9&#34;, whereas the new version checks for a value of &#34;10&#34;. The conversion processing would, among other things, check to see whether the value of &#34;9&#34; was present in working memory data and, if so, change it to a &#34;10&#34;. Conversion processing generally modifies non-control data. For example, it might be necessary to modify the working storage or input/output files of the inferencing session by changing the file format, file address, or data values in fields of the file. Control data could also be modified by conversion if, for example, one rule defined another rule. 
     The CCMDS initiates conversion actions specified by a user who has modified a rule, as shown in detail in FIG. 8 described hereinafter. Step 229 of FIG. 8 shows the recording of conversion actions necessary after the rule is written. This record is not deleted until the rule is released by the inferencing session, as shown in FIG. 4, steps 86 and 88. Then the record is no longer necessary because any new inferencing session will start with compatible working storage, input/output files, rule sets, etc. 
     Presession conversion is initiated, or executed, as shown in step 26. Presession conversion is only necessary when a rule has changed after inferencing has begun, but before inference cycling has begun. Conversion is done for all rules holding I --  RL --  I or I --  RL --  D locks for this session. 
     The inferencing session does any initial processing at step 28, and starts the inference cycle operation 30. At the beginning of the inference cycle, precycle conversion operation 32 executes conversion of data, as necessary, for any rules that have changed since the last cycle begun. Thus, new rules can be incorporated by the inferencing session as often as each inferencing cycle. The inferencing session does not know which rules it will use, so conversion is done for all rules that might be used. Thereafter, inferencing operation 34 evaluates rule premises which causes the CCMDS in step 36 to request R --  RL --  S locks for rules whose premises are &#34;TRUE&#34; so they will be available for use by the inferencing session. R --  RL --  S is a &#34;read rule shared&#34; lock indicating that a rule is being read, but there is no intent to update it, so other sessions may also get a R --  RL --  S lock on that rule. The rules, whose premises are &#34;TRUE&#34;, form the set selected for the next fire/expand cycle, as described above. Inferencing selects a rule from this set in operation 38, fires, or expands it, in step 40, and ends the cycle in step 42. In operation 44, the CCMDS executes any necessary postcycle conversion for the rules which were fired. Post-cycle conversion might be necessary if, for example, a fired rule had set a value that is now inconsistent with the new version of a modified rule. 
     In step 46, the CCMDS commits updates that have been made by firing, expanding, or conversion. This means the CCMDS recognizes the updates as permanent, and they become part of the current &#34;version&#34; of data. Committing rule updates may require updating recorded I --  RL --  I and I --  RL --  D version IDs. In step 48, the CCMDS frees the R --  RL --  S locks since the inferencing session is finished using those rules. 
     Next, in operation 50, inferencing checks to see whether inferencing is complete. If it is not, step 30 returns to start an inference cycle. If inferencing is complete, the CCMDS executes postsession conversion for all locked rules in step 52. Postsession conversion might be necessary, for example, if the session was using the old version of a rule or an output file in an old format. At the end of inferencing, the session would update the format of the file so new inferencing sessions, using the new rule, can use the file as well. The CCMDS then commits updates in step 54, and frees the I --  RL --  I and I --  RL --  D locks in step 56. Operation 58 ends the inferencing session. 
     FIG. 3 shows, in more detail, the interaction between the updating process and the Concurrency Control Manager and Data Store (CCMDS) in the preferred embodiment of the present invention. Updating begins in step 62, and CCMDS 11 requests the R --  RL --  U lock in step 64 in response to the begin updating command from updating. This is a &#34;read rule update&#34; lock indicating that the rule being read will be modified. Updating operation 66 modifies the rule, and step 68 requests a rule update, meaning conversion action as needed, notification, if previously requested, and commit by the CCMDS. The request includes an updating ID for any notification routines, and a delayed or immediate effect indication. In operation 70, the CCMDS requests W --  RL --  I and W --  RL --  D locks as needed and does notification and conversion. A W --  RL --  I (&#34;write rule immediate) lock indicates that the rule has been updated and should be used immediately. A W --  RL --  D (&#34;write rule delayed&#34;) lock indicates that only future inferencing sessions should use the new rule. Updating session then requests commit, in step 72, and the CCMDS commits the updates in operation 74, and frees the locks in step 76. Operation 78 ends the update. 
     FIG. 4A shows the process and operation of freeing a lock. Operation 82 starts the process, and operation 84 checks whether the version of the rule that was locked is either the current version or a version that some other session is using. If so, the record of the lock is deleted in step 90, but the rule is not deleted and the conversion record is not deleted because anyone still using the old rule would need the record to do necessary conversion to successfully update the rule. If neither of those conditions is true, no one needs the old rule or the conversion record, and the old version is deleted in step 86, the record of the conversion actions is deleted in step 88, and the record of the lock is deleted in step 90. Operation 92 ends the process. 
     FIG. 4B shows the process and operation of committing an update. The process starts in step 250. Step 252 makes the updates permanent in storage. Operation 254 checks whether the updates being committed are write updates. If so, any affected inferencing records are updated in step 256 to reflect the current rule versions. Step 258 ends committing updates. 
     FIG. 5 shows the process and operation of requesting a rule lock. Operation 94 starts the process and operation 96 determines the type of lock request. Subroutine 98 (FIG. 6) is called for I --  RL --  I and I --  RL --  D locks. Subroutine 100 (FIG. 7) is called for R --  RL --  S and R --  RL --  U locks. Subroutine 102 (FIG. 8) is called for W --  RL --  I and W --  RL --  D locks. Operation 104 returns the request result and the version if the version was set. Operation 106 ends the process. 
     FIG. 6 shows the process and operation of requesting inference locks I --  RL --  I and I --  RL --  D. Operation 108 starts the process. Operation 112 checks whether the rule entity is locked and, if so, operation 114 tests to see whether the lock is temporary (temp). Temp locks are used by the system to delay processing of other lock requests for the same rule until the current lock request is resolved. If it is a temp lock, step 116 suspends the process until it is removed. Either way, the condition is recorded in step 118, and the protocol matrix is checked in step 120 to determine the appropriate action. If the lock was granted, or if the rule wasn&#39;t locked in operation 112, an identifying record is made in step 130 containing the lock data the system needs to keep track of the lock and the lock holder. This data would preferably include a unique transaction identifier (trxid), a session identifier, a lock identifier, an inference transaction identifier (intrxid), a rule entity identifier, a delay or immediate indicator, an identifier indicating whether early, late, or no notification is needed. Next, the request result is set to &#34;granted&#34; in step 132. 
     If the condition was &#34;notify&#34; in block 122, early notify routines are executed in step 124, and activity is suspended until all replies are received in step 126. If all replies are &#34;grant&#34; in the condition detected in step 128, a record is made in step 130. Otherwise, operation 134 sets the request result to &#34;DENIED&#34; and proceeds to step 136. Early notification means the lock holder wants the lock request refused until successful negotiation occurs (if negotiation is possible). Successful negotiation means that the conflict is removed. Either the original lock holding program gave up the lock or changed it to a nonconflicting lock with the lock requested by the requestor program, or the requestor program changed the lock requested to a lock which did not conflict with the lock held by lock holding program. The result of a successful negotiation is that all replies to the CCMDS are &#34;grant&#34;. Late notification means the holder only wants to know that the lock was granted, but does not want to block the lock. 
     FIG. 9 shows the protocol matrix used in FIG. 6 by operation 120 and operation 122 which returns &#34;yes&#34; or &#34;notify&#34;. If all replies from lock holders are &#34;grant&#34;, the CCMDS at step 128 generates a success message (YES) indicating that the negotiation to resolve the conflict was successful as discussed above. Step 130 then creates an identifying record, and the request result is set to &#34;grant&#34; in step 132. If any of the replies were not &#34;grant,&#34; the step 128 generates a failure message (NO) indicating that negotiations to resolve the conflicts failed, and the request result is set &#34;denied&#34; in operation 134. 
     Next, if step 136 determines that a temp lock was recorded in step 118, that record is deleted in operation 138. Operation 140 checks whether late notify routines have been recorded as a result of other locks having been granted for the same rule entity. If so, they are executed in step 142. The request result is returned in step 144 and operation 146 ends the process. 
     FIG. 7 shows the process and operation of requesting read locks R --  RL --  S and R --  RL --  U. Operation 150 starts the process and operation 152 checks whether the rule is already locked. If so, operation 154 determines whether a temp lock is in effect. If it is, step 156 suspends activity until the lock is removed. Either way, an identifying record indicating the status of the rule is made in step 158, and the protocol matrix is checked for action in step 160. If the lock is &#34;granted&#34;, as detected in step 162 or if it wasn&#39;t locked in the first place in operation 152, operation 170 tests whether the session holds a prior R --  RL --  S lock and is now requesting an update lock, and step 172 creates a copy of the rule and upgrades the lock to R --  RL --  U, allowing the requester to modify the copy of the rule. The record is updated to reflect the new lock and multiple versions of the rule. When the new version of the rule is written, the old version will be deleted. 
     Next, operation 174 checks whether R --  RL --  S was requested from within I --  RL --  I or I --  RL --  D transaction, and step 176 uses the recorded locked version if an inferencing session made the request. If this is a new Update lock request, as detected by operation 178, operation 180 creates a new version of the rule so that it can be updated. Next, an identifying record is made in step 182. The request result is set to &#34;granted&#34; in step 184. 
     If, in operation 168, any replies from prior lock holders were not &#34;grant&#34;, the request result is set to &#34;denied&#34;. Whether the result is &#34;granted&#34; or &#34;denied&#34;, some clean up is done. Operation 188 checks whether a temp lock was recorded in step 158, and step 190 deletes the record if so. If prior late notify routines were recorded for the rule as determined in step 192 they are executed in step 194. The request result and version are returned in step 196, and operation 198 ends the subroutine. 
     FIG. 8 shows the process and operation of requesting write locks W --  RL --  I and W --  RL --  D. Operation 202 begins the process and operation 204 tests whether the rule is locked. If it is, operation 206 checks whether a temporary (temp) lock is in effect, and step 208 suspends action until this temporary lock is removed. Either way, an identifying record is made in step 210 and the protocol matrix is checked in step 212 to determine the appropriate action. 
     If the condition detected in step 214 is &#34;notify&#34;, early notify routines are executed in operation 216, and activity is suspended until all replies are received in step 218. If all replies are &#34;grant&#34;, as detected in step 220 (conflict negotiation was successful), or the condition from the protocol matrix was &#34;grant&#34;, as detected in step 214, or the rule wasn&#39;t locked in step 204, then operation 222 determines whether the current version has a I --  RL --  D lock on it. Step 224 retains a copy of the current version for that transaction if the current version has I --  RL --  D locks. An I --  RL --  D lock means that another session is using the old version, so a copy of it must be kept until the other session finishes. The old version will eventually be deleted by step 86 of FIG. 4A showing the operation of freeing locks. Whether an old version is retained in step 224 or not, the process creates a new version as current for writing to in step 226 and creates a lock record in step 228 which is deleted in step 236. A conversion record is created in step 229, which is retained until step 88 of FIG. 4A when the old rule is deleted and the conversion record is no longer necessary. The conversion record includes identifiers indicating the actions needed for presession, precycle, postcycle, and postsession conversions. The CCMDS initiates these steps at appropriate points in the inferencing session. The request result is set to &#34;granted&#34; in step 230. 
     If the condition determined in step 214 from the protocol matrix was &#34;denied&#34;, or if all of the replies in step 220 were not &#34;grant&#34; (conflict negotiation failed), the request result is set to &#34;denied&#34; in step 232. Whether the request was granted or denied, operation 234 now checks whether a temp lock was recorded, and step 236 deletes the record if so. Operation 238 checks whether late notify routines were recorded as a result of earlier lock requests. If so, step 240 executes them. The request result is returned in step 242, and the process ends in step 244. 
     FIGS. 9A and 9B show the locking protocol matrices in detail. A table is shown in FIG. 10 to assist in reading each locking protocol matrix. In FIG. 9A, the column along the left indicates the lock that is already held, while the row along the top indicates the lock requested. The top portion of the matrix is used when the session holding the lock is using either an old or a current version of the production rule, while the bottom portion is used when the lock is using the current version of the rule. Some lock types can only apply to the current version. For example, a session wouldn&#39;t hold an I --  RL --  I lock on an old version of a rule. The action indicated in the block where a row and column meet indicates the CCMDS response to that situation. For example, when an I --  RL --  D or  --  I lock is held on a rule, any other lock may be granted, with the exception of R --  RL --  U, W --  RL --  I and W --  RL --  D requests, in which case, the inferencing session and the session(s) holding the lock(s) will be notified. Late notify routines just inform the holder of locks that are granted. Early notify routines permit negotiation between the holder and the requester. Conversion routines allow adjustments to be made to existing execution sessions to allow immediate use of new rules, or continued use of old ones. Default routines pick a safe response if notify is indicated but the users have not specified a response. The holding session(s) can consent to lock requests by changing the type of locks they hold or removing locks. For example, in the case where an I --  RL --  D is held and a W --  RL --  I lock is requested, either the inferencing session must change its lock to permit immediate updating (to I --  RL --  I), or the updating session must change the lock it is requesting to update after the inferencing session is complete (to W --  RL --  D ). 
     A held R --  RL --  S lock requires notification and negotiation in the same cases as an I --  RL --  D lock, but is held only while the rule is active, rather than for the entire inferencing session. A held R --  RL --  U also requires notification and negotiation when a R --  RL --  S lock is requested. 
     FIG. 9B is similar to FIG. 9A, but also includes the common serial access protocol for non-rule, non-control data. It illustrates that there is no potential for conflicts between locks on control and non-control data, and also allows comparison between the present invention and the more traditional protocol. Requests for locks for reading and writing data have the potential to be contradictory and non-negotiable because only one person may change a given block of data at a time. If a user holds a R --  DT --  S lock, for example, no one can get a W --  DT lock. If a R --  DT --  U lock is held, neither another R --  DT --  U nor a W --  DT lock may be granted. Also, a W --  DT lock blocks R --  DT --  S, R --  DT --  U and W --  DT locks. 
     Similarly, in FIGS. 9A and 9B, held locks for writing rule modifications can conflict. Thus, if a W --  RL --  D or  --  I lock has been granted, a request for another W --  RL --  D or  --  I lock must be refused. 
     FIG. 10 illustrates the full lock type names, and the abbreviations that are used in the figures and detailed description. 
     FIG. 11 shows another preferred embodiment of the invention. The present invention is useful for managing concurrent access to control data by ordered rule processors, such as workflow managers. FIG. 11 shows the communication between the Concurrency Control Manager and Data Store (CCMDS) and the ordered rule processor in an execution session. All of the previous figures and description apply equally to this embodiment of the invention if it is kept in mind that I --  RL --  I and I --  RL --  D are executing locks requested by any executing program including an inferencing program or an ordered rule processor. 
     Process step 260 begins the process execution instance. The ordered rule processor signals the inference transaction in step 262, and the CCMDS requests I --  RL --  I or I --  RL --  D locks for all procedural rules to be used by the session in step 264. Conflicts are handled according to the protocol matrix shown in FIGS. 9A and 9B, and described in the text above. Recorded precycle conversion is performed in step 264 if the conversion conditions specified are met. In other words, the user that updates a rule for which a lock is sought can specify that certain conversion activities occur before the rule is used. These activities might include defining or reformatting data to be used by the rule. The updater defines the conversion to be performed and the conditions for performing the conversion as part of the request to update the rule. (See FIG. 8, step 229.) The sequential nature of ordered rule processing permits conditions on conversion to be specified. For example, an updater could specify that conversion should be performed only if a specific point in a series of rules has been reached, or if a particular combination of rules has been executed. 
     The Ordered Rule Processor (ORP) then reads a rule (or set of rules) to be executed in step 268. The CCMDS requests read rule shared locks on these rules. The locks are obtained and conflicts are handled, as in the first embodiment. In operation 272, the ORP evaluates the premise of the next rule in order, and in operation 274 the ORP executes the rule&#39;s specified actions if the premise is true. The ORP signals the process cycle end in step 276. The CCMDS executes postcycle conversion, if specified conversion conditions have been met, and commits updates, as described hereinabove, in step 278. The process then returns to the ordered rule processor at step 280. In step 280, the ORP loops to step 272 if any rules read in step 268 remain to be processed. If no rules remain, then the CCMDS releases the R --  RL --  S locks since the ORP is finished with those rules. ORP step 284 checks whether the execution session is done. If not, the ORP loops to step 268. If so, the ORP signals that execution is complete in step 286. The CCMDS executes postsession conversion if conditions are met, and commits updates in step 288. The CCMDS frees the I --  RL locks in step 290. ORP step 292 ends the process execution instance (and the associated inference transaction). Except as specified above, requesting locks, handling conflicts, performing conversion, committing updates, etc., are performed exactly the same as in the first embodiment. 
     While the exemplary preferred embodiments of the present invention are described herein with particularity, those having normal skill in the art will recognize various changes, modifications, additions and applications other than those specifically mentioned herein without departing from the spirit of this invention.