Focuses on the partitioning of rules for parallel matching in a production system. The approach, called PARTES, applies the min-cut technique to a dataflow discrimination network (DDN) that represents the antecedents of the rules. The goal is to maximize the sharing of memory nodes within a partition while minimizing the duplication of nodes across partitions. The authors illustrate the technique using a cost model based on shared memory nodes defined in a DDN created by the Rete algorithm. A generalization to any other algorithm utilizing a DDN is straightforward. A performance analysis is provided to show the effectiveness of PARTES.

A transaction model for active databases is introduced. Concurrent execution of rules needs to be carefully managed to ensure consistent semantics. It is shown that serializability is not always sufficient for correctness. A new criterion, conditional conflict serializability (CCS) is developed and shown to ensure the desired correctness. A graph-based scheduler for it is presented. Practical schedulers should also be recoverable, which the graph-based scheduler is not. The authors prove that conventional two-phase locking also achieves CCS, and can thus be used in practice.>

A study is made of the issues in parallelizing database production systems. Various kinds of parallelism possible in production systems are classified. Parallel execution of production systems leads to some subtle problems which, if not handled carefully, can cause altered execution semantics. The precise conditions that any parallel implementation of production systems must fulfil in order to be semantically consistent are identified. A mechanism that guarantees the semantic consistency of parallel execution and proves its correctness is presented. It is based on a novel locking mechanism that provides more parallelism than conventional two-phase locking. The various factors that can affect the actual speedup of a database production system are discussed.>

The authors address the problem of error recovery in a system of distributed communication processes. They show that if each process can detect its local computation errors while establishing the recovery points, then the amount of process dependencies can be reduced by exploiting the temporal ordering of message communication among the processes. The proposed approach allows processes to proceed independently during normal computation, and can be further improved to accommodate independent rollback without explicit coordination. The authors also discuss the handling of messages that are originated from, or received by, tasks that later abort. Simulation studies indicate that the approach taken achieves a much higher throughput than the synchronous approach.>