Predicting programs' response time (the longest execution time) has been a challenging task, especially for rule-based programs, in which the control flows are not obvious. To facilitate our study on this problem, we chose the EQL language as our target rule-based language. An EQL program can be thought of as an operator in a prototype system description language such as PSDL. In this paper we show how to generate executable code from an EQL rule-based program and to verify its timing behavior. We have developed a suite of packages to derive response-time bounds for EQL programs. Such timing analysis tools can be used in timing verification for program prototypes in the early stage of software development. The response-time bounds are derived in three steps: First an EQL program is translated into an equivalent C program, which can then be compiled for execution. The translated C program is also used as input to a timing-analysis tool to get execution time information for each rule firing. To derive a response-time bound of the program, the EQL program and the rules' firing-time information are used by a response-time analyzer. In this paper we describe the functionalities of these packages, with emphasis on the EQL-to-C translation. An EQL program example is also used throughout this paper to demonstrate the procedures.

A key index of the performance of a rule-based program used in real-time monitoring and control is its response time. We first extend the definition of response time of an EQL rule-based program for distributed computation. To reduce the response time through distributed computation, we decompose an EQL program into disjoint modules. We then describe a tool which computes the response-times of finite-state EQL rule-based programs according to the imprecise computation paradigm, i.e., this tool always yields a range which is monotonically tightened as more time is spent in the computation. During the computation, a user can interrupt the analyzer and get both an intermediate result which is a guaranteed bound and a bound-quality factor which quantifies the tightness of this result. Our approach uses fast textual analysis to get initial bounds. It then performs a heuristic search by pruning the state-transition graph to improve the bound quality. A program-decomposition technique for reducing the search effort is also discussed. An analysis example on an EQL program involving 259 states is presented

In this paper we describe a purely declarative method for introducing modularity into forward-chaining, rule-based languages. The method is enforced by the syntax of the language and includes the ability to parameterize the rule groups. We also describe the Venus programming environment, which implements the presented ideas. Drawing from two of three Venus applications developed to date, we illustrate how this form of modularity contributes directly to the resolution of certain software engineering problems associated with rule languages. We also discuss key implementation details and present performance data.

We describe a purely declarative method for introducing modularity into forward-chaining, rule-based languages and its embodiment in the Venus rule language. The method is enforced by the syntax of the language and includes the ability to parameterize the rule groups. Drawing from two of three Venus applications developed to date, we illustrate how this form of modularity contributes directly to the resolution of certain software engineering problems associated with rule languages.< >

The response time of a rule-based program is deened as the maximum number of rule rings before a xed point of the program is reached from a start state. In this paper, we present several principles which make use of two relations, potential-trigger and suppression, for deriving tight response-time bounds. While the computation of these two relations is costly in general, we show how they can be eeciently approximated by reening the necessary/suucient conditions for these relations to be satissed. A response-time analyzer based on the theories in this paper has been implemented to analyze programs whose potential-trigger relations are acyclic. We demonstrate the analysis process with an example program which has innnite state space. Our analyzer takes only seconds to derive a tight bound on the example pro-gram's response time.

The authors have developed a powerful and efficient analysis methodology for a large class of rule-based EQL programs to determine whether a program in this class has bounded response time. In particular, the authors identified several sets of general behavioral constraint assertions: an EQL program which satisfies all constraints in one of these sets of assertions is guaranteed to have bounded response time. The authors enhance the applicability of this analysis technique by introducing a facility for the rule-based programmer to specify application-specific knowledge in the language Estella to validate the performance of an even wider range of programs. This facility can be viewed as a computer-aided software engineering tool for aiding the rapid prototyping and development of expert systems with guaranteed response time

Automated Analysis of Bounded Response Time for Two NASA Expert Systems* Chih-Kan Wang Duu-Chung Tsou Rwo-Hsi Wang James C. Browne Aloysius K. Mok Department of Computer Science University of Texas at Austin Austin, Texas 787 12–1 188 The response time of an expert system E is defined by the maximum number of rule firings for E to arrive at a stable configuration in response to a change in the input. For time-critical applications, it is important for expert systems to have bounded response time so as to react effectively to changes in the environment. We report on the application of a set of tools to demonstrate the boundedness of the response time of two expert systems from NASA applications: the Space Shuttle Orbital Maneuvering and Reaction Control Systems’ Valve and Switch Classification Expert System (OMS) and the Space Station Integrated Status Assessment Expert System (ISA). The work reported herein builds on and extends previous work in the timing analysis of EQL rule-based systems by generalizing EQL analysis techniques to deal with the variable-size working memory. An OPS-like language, MRL which uses EQL as a “core language” has been designed to facilitate the analysis. *This project is supported by research grants from Office of Navrd Research under ONR contract number NOOO14-89-J-1472 as wetl as ONR contract number NOOOO14-89-J-1913, and also by a grant from Texas Instnr mcnts Corporation. Permission to copy without fee all or part of this material is granted provided that the copies are not made or distributed for direct commercial advantage, the ACM copyright notice and the title of tha publication and its date appear, and notice is givan that copying is by permission of the Association for Computing Machinery. To copy otherwisa, or to republish, raquiras a fee and/or specific permission. @ 1991 ACM 0-89791.455-4/91/001 1/0147... $1.50