DEBL(ID:6859/)for Distributed Event-Based Language References: Distributed computation has been increasingly important due to the demand for more computation power. However, distributed programs are also difficult to write and debug because of the asynchronous autonomy property ofilldividual processes. Different computer systems are connected only by communication channels, therefore a physical global clock is not available in many distributed systems [Lamp 78]. As a result "events" which occur in a program can only be partially ordered. Most of the existing concurrent program specification langaages or systems focus on central or interactive execution control [Baia 86], [Helm 85], [LeDo 86]. The former approach is very timeconsuming and inefficient. The latter approach tends to alter the execution course of a distributed program since artificial time distortion may be introduced into the program execution. The semantics of a distributed program can be separated into two parts: inter-process communication (IPC) and individual process semantics. The IPC is regarded as a more difficult but little understood area since each process by itself is just a sequential program. The IPC aspect of distributed programs is our focus. Our goal in debugging distributed programs is to have the debugging procedure automatically and distributively executed at each local computer system, and have execution error(s) isolated to process levels. Each potential faulty process can then be examined and tested independently and concurrently. A specification language (DEBL) that allows individual process behavior to be described in terms of local IPC events is designed for this purpose. A knowledge-base construct is also integrated into it. DEBL is based on a formal temporal logic system (TEL) to ensure rigorous deduction. That is, the specification expression of DEBL will be transformed into a corresponding logic formula of TEL. To interpret the specification expression is equivalent to evaluating the corresponding logic formula. DEBL provides a structured and user-oriented description tool and TEL supplies a formal base. Together, they are the inference engines of a knowledge-based system where DEBL serves as the front-end processor of TEL. DEBL provides an event hierarchy to conform to a programmer's logical concepts. Processes are specified in terms of ilLdividual IPC activities. Temporal logic is used for expressing timerelated properties. The knowledge-base has the same structure used by the user-defined process to provide a uniform view of the system structure. Instead of interactively controlling the program execution, our approach is a retrospective one. That is, we examine the consistency between the process specification and the trace of execution. No further coordination between computer systems is required. The results are forwarded to a control agent to determine possible faulty processes. Figure 1 pictures the system structure of our distributed knowledge-based debugging system. This paper gives an overview of the specification language- Distributed Event-Based Language (DEBL). The detailed description of TEL, transformation rules from DEBL to TEL, and a complete description of a distributed knowledge-based debugging system can be found in [Cheng 88]. The basic concepts, syntactic structures, and informal semantics of DEBL will be described in this paper. We will also briefly discuss TEL. Extract: Overview of DEBL Overview of DEBL The basic event unit of DEBL is the "primitive event". Specifically, it represents an inter-process communication activity. A primitive event is considered "instantaneous" which takes zero time to complete. Two inter-process communication mechanisms are identified in DEBL, i.e., synchronous and asynchronous IPC. For instance, a primitive event such as (S, R, msg, Sit) expresses that "S" is the sending process and "it" is the receiving process. The data being transmitted is of "msg" type. "Sit" indicates that this is a synchronous communication. If we have a (S, it, msg, it) instead, then it will be an asynchronous communication and is a receiving action performed by R. On the other hand, if we have a (S, it, msg, S), it will be a sending action performed by S. Conceptually, each process is an event stream and a distributed program is a graph of these event streams. The nodes in this graph are IPC events and the arcs depict the relation of sending and receiving IPC messages. The graph may consist of several independent "connected" sub-graphs. For example, a computer network is divided into isolated sub-networks due to break-downs of communication lines. For a totally isolated process, which does not have any inter-process communication with other processes, its description will not exist or be NULL in our system. During program execution, inter-process communication messages will be recorded. After that, these traces of IPC messages are used for matching against a DEBL specification of the distributed program. A BNF definition of DEBL is provided in the Appendix. in [ACM] Proceedings of 17th ACM Annual Computer Science Conference : Computing trends in the 1990's Louisville, Kentucky, United States 1989 view details |