RDL/C(ID:7136/rdl003)


Related languages
RDL1 => RDL/C   Response to criticism Evolution of
References:
  • Kiernan, G.; De Maindreville, C. "The RDL/C language reference manual V1" Rapport technique de l'INRIA-Rocquencourt RT-0123 October 1990 view details
  • Shiow-Yang Wu "Decomposition Abstraction In Parallel Rule Languages" Department of Computer Sciences The University of Texas at Austin view details Abstract: As the applications of production systems expand from traditional artificial intelligence domains into the data intensive and real-time arenas, program complexity and the volume of data also increase dramatically. Over a decade of efforts to exploit this opportunity, the previous approaches of employing parallel match and/or syntactic based multiple-rule-firing have failed to raise the  performance to a satisfactory level. Based on the observations made in a pilot study, we found that by incorporating application semantics, it is possible  to achieve a much higher level of concurrency than what can be achieved by  traditional techniques. This dissertation presents a new approach called decomposition abstraction that aims at the exploration of application parallelism  in production systems.
    Decomposition abstraction is the process of organizing and specifying parallel decomposition strategies. We propose a general object-based framework and present the formal semantics of a set of decomposition abstraction  mechanisms that are applicable to any rule language. A semantic-based dependency analysis technique that uncovers hidden concurrency based on a new  notion of functional dependency successfully derives parallelism that is very difficult, if not impossible, to discover by traditional syntactic analysis techniques.  The effectiveness of our approach is validated both by simulation and  implementation on Sequent Symmetrymultiprocessor. The performance results  demonstrate the potential of the decomposition abstraction approach to achieve  linear and scalable speedup. External link: Online copy Extract: RDL/C
    In response to these deficiencies of the RDL1 approach, a new rule language compiler called RDL/C [23, 74, 75] is developed which not only supports procedural constructs and C language interface, but also enable a program to run on  top of any relational DBMS because the interface between the rule language  and the DBMS is SQL. More importantly, RDL/C provides language constructs, execution model, and run-time environment for supporting rule-level  parallelism. We now briefly describe the RDL/C approach.
    RDL/C is derived from RDL1. The language supports both declarative programming in the form of production rules, and procedural programming based on C code. The original design of RDL/C does not include constructs  for parallelism. Similar to RDL1, the condition part of a RDL/C rule is a  tuple relational calculus expression with the declaration of range variables in  front. The expression is to qualifies the tuples for participating in the rule's  firing. The actions can be insertions, deletions, C-like variable assignment and  external procedural calls. The semantics of RDL/C rules is set-oriented in  the sense that when a condition is evaluated against the database, the set of  instances satisfying the condition is returned. Similarly, when an action is executed against the database, it is executed for all the values which appear as  arguments in the action. In this respect, RDL/C rules are similar to a construct we provide called ALL combinator. For the execution of a rule program,  one rule is randomly selected for execution among all firable rules in each cycle.  Program execution terminates when no rule is firable. A control sub-language  is also provided as in RDL1 for explicit control over the rule execution. Two  particular expressions BLOCK and SEQ specify non-deterministic or sequential  execution.
    As already mentioned earlier, the original design of RDL/C does not include constructs for supporting parallelism. In [23] the basic design is extended to include constructs for supporting parallelism. First, on the PCN  model, which is the execution model for RDL/C language, sufficient conditions  are identified for parallelizable transitions which correspond to rules in the program. To inform the compiler that the rule module is to be run in parallel,  the ON statement is provided to specify the servers on which the module is to  be executed. Then the PAR structure is added to the control sub-language to  specify how rules are to be run in parallel. A run-time library is provided to  actually manipulate parallelism during execution.
    Though primitive, the RDL/C approach to parallelism is actually a rudimentary form of semantic level parallelism. However, the parallelism is only  supported at the rule level and the programmer must transform application  specific knowledge into an explicit specification of partial order among rules  using the control sub-language. On the contrary, our approach is intended to be  a much more general and comprehensive one that exploits semantic parallelism  at every level of production system. The application specific knowledge is also  expressed and used in a much more natural way.