No full-text available
To read the full-text of this research,
you can request a copy directly from the authors.
XC- A language for embedded rule based systems
Abstract
We report on experiences in the design of the programming language XC. It is an extension of C++ and combines abstract data types with rule based programming. Our design decisions are validated by three application prototypes and by benchmarking XC and OPS83. The experiences raise some critique on the RETE algorithm and on C++ as a host language. However, most of the results are also applicable to other host languages that support data abstraction. XC has been designed specifically to be used in embedded real-time expert systems.
... In that paper, sequential program constructs as well as concurrent programs with synchronization were considered. In this paper, we provide timing analysis for a rule-based language RL (Morin, 1994) with rather different programming characteristics. The program is reactive (Harel and Pnueli, 1985), and the structure of a rule base is flat. ...
... RL programs (Morin, 1994) consist of eventcondition-action rules (Dayal and McCarthy, 1989) . ...
Predictability is a very important feature of complex real-time systems. For a complex system involving a number of subsystems, the timing properties of each embedded system play an important role since the total system’s response depends on temporal behaviour of all the subsystems.
... There also exists a simulator of the PLX, which runs under Unix; @BULLET Process Layer Configuration Language, PLCL, (Morin, 1991) and its compiler: a language for specification of PL module interconnections and interfaces to both sensors and actuators on one side, and to the DRL software on the other side. The modules themselves are programmed in a subset of some conventional language, such as C or C++; @BULLET Rule Layer executive, RLX (Morin, 1994): an engine for implementation of rule-based discreteevent systems in the DRL. It has been implemented on Unix-based machines, and on a PC with VDX and RTLinux; @BULLET Rule Language. ...
... It has been implemented on Unix-based machines, and on a PC with VDX and RTLinux; @BULLET Rule Language. RL (Morin, 1994): a rule-based language for declarative specification of discreteevent control. ...
This Generic Layer Architecture (GLA) has been created to deal with problems of reasoning in conventional process control. It is composed of a process layer, dealing with the external environment, a rule layer, that provides an inference engine associated with a system state, and an analysis layer responsible for planning and reasoning. This results in a hybrid controller that enhances conventional modes of operation by the capability of taking intelligent decisions. In this work, we are extending the concept of GLA by adding into the picture three new environments, to make it suitable for purposes of modeling and simulation. The broader context includes a user interface, network communication and image database, where GLA becomes a core element of a sophisticated real-time information processing system. The extended architecture is applied to a simulation problem from air traffic control -reasoning about, predicting and detecting collisions. In this problem we focus on investigation of timing estimates on the reasoning process to meet hard deadlines in the problem domain.
... We rst motivate the design decisions of XC and XE, explain why the famous RETE (Forgy 1982) match algorithm is not used, and show what data representation and program structuring facilities we think are necessary. Next we describe experiences with XC, reported in more detail elsewhere (Nuutila et al. 1987), and motivate the introduction of XE. Finally we describe XE, relating it to CLU (Liskov et al. 1977). ...
... We were satis ed with the expressive power of XC. Further, in comparative experiments (Nuutila et al. 1987) XC was always more memory e cient and in many cases also more time e cient than OPS83. The experiments also supported the importance of problem speci c algorithms and data structures in rule based embedded systems. ...
We report on experiences of the ExBed project, specifically on adding a rule based expression mechanism to an existing procedural programming language (C++) and on designing and implementing a self-contained language (XE) -- and its programming environment -- supporting similar but more general capabilities. 1. Background Embedded systems are claimed to be a promising industrial AI application. The ExBed project (expert system framework for embedded applications) was established to determine how expert system techniques can be applied within embedded systems running on a microcomputer. Fagan (1980) was the first to attempt the construction of a continuously operating expert system. Based on his experiences the forward chaining inference strategy is usually assumed most suitable for these systems. The state-of-the-art of the OPS production system family, based on the RETE algorithm (Forgy 1982), is represented by OPS83 (Forgy 1984). YES/L1 (Milliken 1985) is a rule-based extension of PL...
... We were satissed with the expressive power of XC. Further, in comparative experiments (Nuutila et al. 1987) XC was always more memory eecient and in many cases also more time eecient than OPS83. The experiments also supported the importance of problem speciic algorithms and data structures in rule based embedded systems. ...
We report on experiences on adding a rule based expression mechanism to an existing procedural programming language (C++) and on designing and implementing a selfcontained language -- and its integrated programming environment -- supporting similar but more general capabilities. Both languages, XC and XE, are based on abstract data types and XE is a close relative of CLU. Its programming environment -- implemented on a LISP workstation -- contains facilities for editing and composing programs, browsing a program data base, debugging, version management, and cross-compilation to various microprocessors, including the Intel 8086. Key words: Programming languages, Embedded systems, Expert systems 1. Background Embedded systems are claimed to be a promising industrial AI application. The ExBed project (expert system framework for embedded applications) was established to determine how expert system techniques can be applied within embedded systems running on a microcomputer. Fagan (1980)...
Although the technology of expert systems has been developed substantially during the past decade, there still seems to be relatively little application to time-critical problems because of their extensive computational requirements. One application area of particular interest is that of process control. Because this area requires real-time operation, the expert system must operate within the time scale of the process involved. Here we present techniques which have been used to implement PAMEL,A, a language suitable for building time-critical expert systems. We discuss substantial optimizations of the well known RETE algorithm and present run-time measurements based on these optimizations. Despite the critics on RETE's real- time behaviour we show that the presented optimizations and extensions will cover the demands of many real-time applications. In order to eflciently support process control applications, some useful language constructs concerning interrupt handling and rule interruption are discussed.
This paper presents the syntax and semantics of a component-oriented rule-based language for specifying the formal models of manufacturing systems. A model captures the state of a component of the system in a set of first-order logic predicates, and it captures the semantics of the operations performed by this component in a set of rules that determine the preconditions and postconditions of an operation. The models are then used to plan the sequence of operations of each class of jobs to be manufactured by these systems. A plan-oriented fault detection and correction strategy is proposed. This strategy can automatically handle any combination of faults that may occur when monitoring the operations of manufacturing systems. A fault-tree is consulted prior to executing the scheduled operations of a plan, and the faults that affect the execution of these operations are handled subsequently. Resuming the original cyclic schedule is attempted, whenever feasible. As a proof of concept, a prototype implementation of both the main constructs of the component-oriented rule-based language and the planning and fault-recovery algorithms presented in this paper have been completed. This prototype is implemented on a Unix-based system in the Ada programming language. The specification of a manufacturing system is first expressed in the proposed language. These statements are then translated into Ada code. This code is next compiled by a Verdix Ada compiler and is executed in order to create and populate the model data structure of the system. A detailed plan of execution and a set of fault-recovery plans may then be derived for a job to be manufactured on this system.
We argue that a reactive agent obeying the requirement of predictability imposed by a hard-real-time application domain cannot
be equipped with an arbitrarily powerful deliberation capability as this would jeopardize the predictability of the agent’s
behaviour. Therefore such augmentation should be performed in a principled, controlled manner. We illustrate our line of thought
with the example of Generic Layered Architecture used for creating reactive agents acting in dynamic environments requiring
real-time responsiveness.
A specification tool for distributed systems that uses the idea of
applicative state transition systems is used to obtain an executable
specification of the system behavior. A distributed system is regarded
as a set of applicative state transition (AST) systems. Integration of a
rule-based component into an existing applicative specification method
for distributed systems produces a suitable language for the formulation
of distributed production systems. This language unifies the model of
AST systems with a (forward chaining) production system and with C.A.R.
Hoare's (1985) ideas of communicating processes
Rule-based programming is studied in the context of embedded expert systems. Problems in using traditional rule-based languages for embedded applications are pointed out. The problems are related to data representation, program structure, interaction with procedural code, program reliability, and to the RETE pattern matching algorithm that is used in most of these languages. A twofold solution to these problems is proposed. Firstly, rule-based and procedural code is combined in the same language by using abstract data types as the unifying component. Secondly, non state-saving pattern matching algorithms are used instead of the RETE algorithm. To test this solution three programming languages --- XC, XD, and XE --- have been designed. XC extends the C++ language by rules, working memories and rule sets. It is implemented using a preprocessing technique. XE is a new general purpose programming language that combines procedures, iterators, abstract data types, rules, and type parameters. A compiler has been implemented for XE. It is a part of an integrated programming environment. A smart recompilation algorithm is used in the compiler to avoid unnecessary compilations after modifications to the modules of an XE program. XD (not described in this thesis) is an implementation of the XE rule mechanism on top of C and C++. A few application programs have been written in XC and XE. According to the experience, the approach of combining rule-based and procedural programming in XC, XD, and XE is valid.
ions M. Bouteldja J. Arkko V. Hirvisalo J. Kuusela E. Nuutila M. Tamminen Helsinki University of Technology, Department of Computer Science, Espoo, Finland. Abstract Knowledge-based application development for embedded systems requires an approach different from that used in other environments. This is due to the nature of embedded systems which amongst other characteristics, have strong reliability requirements and aim to optimize the use of underlying hardware resources. Any approach that satisfies these constraints must be supported by the development tools. In this paper, we show how the XE programming environment supports embedded knowledge-based software development. The key idea is the integration of the rule-based paradigm with abstract data types in the same programming language environment. We illustrate the ideas through XEDA, an embedded knowledge-based application developed at Nokia Telecommunications to support the diagnostics function of the DX 200 digital switching ...
XE is a programming language designed and implemented at the Helsinki University of Technology by the ExBed project. The design of XE is based on the CLU programming language. This paper discusses differences between the two languages and the design decisions of XE. 1. Background The XE language [Arkk89] and its programming environment have been developed within the ExBed project, which was established to develop software tools for construction of embedded expert systems. The project needed a general purpose programming language with added facilities for rule-based programming. High level abstraction mechanisms and the possibility for efficient static semantic analysis were considered crucial for the language. The main reason for this was the wish to perform as much verification and optimization as possible at compile time to satisfy the stringent requirements of embedded systems. There existed no programming language that satisfied our needs and therefore we decided to design a new pr...
. We argue that a reactive agent obeying the requirement of predictability imposed by a hard-real-time application domain cannot be equipped with an arbitrarily powerful deliberation capability as this would jeopardize the predictability of the agent's behaviour. Therefore such augmentation should be performed in a principled, controlled manner. We illustrate our line of thought with the example of Generic Layered Architecture used for creating reactive agents acting in dynamic environments requiring real-time responsiveness. 1 Introduction The interplay between reactivity and deliberation is one of the issues of paramount importance for intelligent agent 1 design. For many years AI research focused on deliberation as the basis for intelligent activity, neglecting the problems of situatedness and reactivity. Increasing complexity of the problems addressed by the researchers has led to the important insight that appropriate reactivity is probably as necessary and important to...
This paper discusses modularization as a mechanism for improving the flexibility and comprehensibility of a system while allowing the shortening of its development time. The effectiveness of a "modularization" is dependent upon the criteria used in dividing the system into modules. A system design problem is presented and both a conventional and unconventional decomposition are described. It is shown that the unconventional decompositions have distinct advantages for the goals outlined. The criteria used in arriving at the decompositions are discussed. The unconventional decomposition, if implemented with the conventional assumption that a module consists of one or more subroutines, will be less efficient in most cases. An alternative approach to implementation which does not have this effect is sketched.
Large distributed control systems can make overwhelming demands on operators, especially during a process upset. Expert system technology offers a completely new way of augmenting the expertise of operators, and can also deliver cost benefits in the areas of process optimization and scheduling. Here's an introduction to this new approach to 'intelligent' process control systems, with a description of the first expert system ever offered for the purpose.
The expert system structure of programming allows difficult and complex problems to be more easily represented. Problem solving methods similar to expert human inference can be implemented. Specific examples of a process control expert system are used to demonstrate prospective uses.
The author outlines the basics of object-oriented programming. The author defines what object-oriented programming is and what it is not. The author discusses what features a language must have to be considered an object-oriented language.
CLU is a new programming language designed to support the use of abstractions in program construction. Work in programming methodology has led to the realization that three kinds of abstractions—procedural, control, and especially data abstractions—are useful in the programming process. Of these, only the procedural abstraction is supported well by conventional languages, through the procedure or subroutine. CLU provides, in addition to procedures, novel linguistic mechanisms that support the use of data and control abstractions. This paper provides an introduction to the abstraction mechanisms in CLU. By means of programming examples, the utility of the three kinds of abstractions in program construction is illustrated, and it is shown how CLU programs may be written to use and implement abstractions. The CLU library, which permits incremental program development with complete type checking performed at compile time, is also discussed.
This is a combination introductory and reference manual for OPS5, a programming language for production systems. OPS5 is used primarily for applications in the areas of artificial intelligence, cognitive psychology, and expert systems. OPS5 interpreters have been implemented in LISP and BLISS. (Author)
The Rete Match Algorithm is an efficient method for comparing a large collection of patterns to a large collection of objects. It finds all the objects that match each pattern. The algorithm was developed for use in production system interpreters, and it has been used for systems containing from a few hundred to more than a thousand patterns and objects. This article presents the algorithm in detail. It explains the basic concepts of the algorithm, it describes pattern and object representations that are appropriate for the algorithm, and it describes the operations performed by the pattern matcher.
CLU is a new programming language designed to support the use of abstractions in program construction. Work in programming methodology has led to the realization that three kinds of abstractions, procedural, control, and especially data abstractions, are useful in the programming process. Of these, only the procedural abstraction is supported well by conventional languages, through the procedure or subroutine. CLU provides, in addition to procedures, novel linguistic mechanisms that support the use of data and control abstractions.This paper provides an introduction to the abstraction mechanisms in CLU. By means of programming examples, we illustrate the utility of the three kinds of abstractions in program construction and show how CLU programs may be written to use and implement abstractions. We also discuss the CLU library, which permits incremental program development with complete type-checking performed at compile-time.
Typescript. Thesis (Ph. D.)--Carnegie-Mellon University, 1979. Bibliography: leaves 175-178. Photocopy. s
Hexscon (Hybrid Expert System Controller), an experimental knowledge-based expert system intended to deal with control problems encountered in military and advanced industrial applications, is discussed. Hexscon combines algorithmic real-time control techniques with knowledge-based approaches to higher level reasoning to organize the inference engine at different levels of detail. Among Hexscon's design goals are a capacity of 5000 rules in 512K-byte microcomputer, a response time of 10 to 100 ms, control of about 1000 objects, and continued functioning in an uncertain environment. A prototype has demonstrated these capabilities in several problem domains.
A continuous real time expert system
- J H Griesmer
- S J Hong
- M Karnaugh
- M I Schor
- R L Ennis
- D A Klein
- K R Milliken
- H M Van Woerkom
- Yes
- Mvs
STIMULUS' - a base language for real time expert systems
- J Robertson
Ventilator manager: a program to provide on-line consultative advice in the intensive care unit
- L Fagan
Specification of XC. Internal report Helsinki University of Technology
- E Nuutila
- J Kuusela
On the Efficient Implementation of Production Systems Carnagie-Mellon University Department of Computer Science
- C L Forgy
DXPERT : An expert system for complex alarm interpretation in the DX200 digital switching system
- M Bouteldja
- Bouteldja M. DXPERT