Xinming Tan

Specification of the RTPA grammar and its recognition

A new type of descriptive mathematics, real-time process algebra (RTPA), is developed for describing complicated behaviors of human beings and software systems. This paper describes the key syntax of RTPA defined by a set of 280 LL(k) grammar rules and their recognition techniques. The LL(k) grammar of RTPA is formally described by using the EBNF notations. The design of the RTPA parser and type checker are presented on the basis of the RTPA grammar. To deal with the special non-LL(k) grammar rules of RTPA, the ANTLR syntactic predicates are used to create guarded and extended rules. The tasks of type checking in RTPA recognition can be classified into three categories: (a) identifier type compliancy, (b) expression type compliancy, and (c) process constraint consistency. The implementation of the RTPA parser and type checker provides an important tool for RTPA recognition and for generating executable code for formal specifications of system architectures and behaviors in RTPA.

Design and Implementation of an Automatic RTPA Code Generator

Real-time process algebra (RTPA) is a mathematics-based notation system for the specification and refinement of realtime and safety-critical systems. This paper presents the work on designing and developing a set of tools that facilitate automatic generation of C++ code from RTPA specifications of system architectures and behaviors. A two-phrase strategy has been employed in the design of the toolkit. In the first phrase, an RTPA specification is lexically and syntactically analyzed and type-checked, which results in a set of abstract syntax trees. In the second phrase, C++ code is generated using the RTPA-to-C++ mapping strategies and patterns when walking down the abstract syntax trees. The RTPA-to-C++ mapping strategies specify both the traditional sequential part of RTPA mapping onto the standard C++ library and the real-time features of RTPA, such as interrupt, concurrency, duration, and event/time-driven dispatch, mapping onto the RTPA run-time library, which provides real-time support and is implemented using real-time kernel techniques. The toolkit implemented includes an RTPA lexer, an RTPA parser, an RTPA type-checker, and an RTPA code-generator. The experimental results show that RTPA specifications can be rigorously checked and corresponding C++ code can be automatically generated from RTPA specifications using the toolkit. The automatically generated code is executable and effective under the support of the standard C++ library and the specially developed RTPA run-time library

A novel type checker for software system specifications in RTPA

This paper presents a type checker for formal specifications of software systems described in real-time process algebra (RTPA). The grammar of RTPA is formally described by using the EBNF convention. Design and implementation techniques are presented that keep the RTPA syntax as close to its original mathematical notations as possible, and at the same time, allow it to be parsed easily as a super higher-level language. The tasks of type checking for RTPA specifications can be classified into three categories: (a) identifier type compliancy, (b) expression type compliancy, and (c) process constraint consistency. The RTPA type checker has been designed and implemented to support system architects and system analysts to ensure the correctness and consistency of system specifications to a maximum extent.

Implementing task scheduling and event handling in RTOS

An important component in the kernel of a real-time operating system (RTOS) is the task scheduler. Various solutions on task scheduling, such as priority inheritance and priority ceiling, have been proposed to deal with the priority-inversion problem that arises when a preemptive priority driven scheduling scheme is used. However, the priority inheritance protocol introduces drawbacks such as multiple blocking of tasks and deadlock, while the priority ceiling protocol is hardly supported by most existing real-time operating systems. We first present a formal description of a task scheduling algorithm that provides a solution to the priority inversion problem and eliminates multiple blocking of tasks running in a single processor platform. We use RTPA (real-time process algebra), a formal specification notation, to describe rigorously the architecture, and static and dynamic behaviours of the task scheduler. Our method employs a multi-queue based scheduling system in which all tasks pending on a resource or event are put into different queues with preassigned priorities. This technique eliminates the problem of priority inversion and prevents multiple-blocking and deadlock from happening. Based on the new method, a framework for implementing task scheduling and event handling is implemented for RTOS+, which is a portable real-time operating system developed by the authors.

Specification of abstract data types using real-time process algebra (RTFA)

The real-time process algebra (RTFA) provides a new approach to the specification and refinement of real-time systems. This paper presents a study on the specification of a set of abstract data types (ADTs) by using RTPA. The objectives of this work are to demonstrate the expressiveness of the RTPA notations and specification method, and to build a fundamental ADT library for RTPA by recursively applying the RTPA notations. Eleven ADTs, such as stack, record, array, queue, sequence, list, etc., have been selected and specified in RTPA. An ADT, Queue, is adopted in this paper to shown the RTPA specification and refinement methods. The queue specification in RTPA is contrasted to a conventional logic-based specification, and the features and advantages of the RTPA notation system is demonstrated. This case study shows that with RTPA, ADTs can be described and specified not only as static data types, but also dynamic real-time components, which enables ADTs to be applied in the real-time environment as predefined or embedded special architectural components.

An RTPA supporting environment for Java code generation

Real-time software development from formal specifications requires tools and suitable supporting environments to facilitate the development process. The need for such tools becomes more pronounced if the development language is Java; because Java suffers from the unpredictable behavior of the garbage collector. This paper presents a supporting environment for developing real-time software using Java from formal specifications in RTPA. The supporting environment has two major components: a real-time support library that provides extended real-time library functions for the generated Java code, and a real-time kernel (RTOS+) that provides efficient real-time services to the system. By automatically generating Java code from formal specifications, the programmer is relieved of the burden of interpreting the specification before writing code in Java and at the same time is able to take advantage to develop real-time applications in Java under the support of the real-time support environment

Formal description of the ADT model of B-Trees

Formal specification of abstract data types (ADTs) is important in modeling system architecture and their implementations. B-Trees are one of the most widely used ADT in system development. This paper presents a formal approach to the specification of B-Tree using real-time process algebra (RTPA), which is a newly developed mathematics-based notation system for the specification and refinement of real-time and safety-critical systems. The logical model of B-Tree has been abstracted first. The RTPA specification of B-Tree is based on the logical model. In the RTPA specification, B-Tree has been formally described in three parts: system architecture, static behaviors, and dynamic behaviors. In the architectural specification, both logical model and physical implementation model of B-Tree has been specified. The logical model of B-Tree uses RTPA component logical models to present the structure of a B-Tree by nodes and characteristics; while the physical implementation model of B-Tree uses linked list to describe the implementation of a B-Tree. In the behavioral specification, three kinds of B-Tree behaviors, namely traversal operations, manipulation operations, and query operations, have been abstracted and specified by RTPA processes. This work is a part of the effort to build an ADT library for RTPA in the RTPA-based code generation project

Transforming RTPA Mathematical Models of System Behaviors Into C

Real-time process algebra (RTPA) is an expressive mathematical means for describing cognitive behaviors and processes of human beings and software systems. This paper presents the strategies and patterns for transforming mathematical models of system behaviors in RTPA into C++. An RTPA code generator towards the simulation of system behaviors and processes is implemented, which transforms system architectures and behaviors into C++ based on the RTPA-to-C++ mappings strategies and patterns, as well as the RTPA runtime library. The generated code in C++ is executable and effective for simulating system behaviors specified in RTPA

Implementing the Real-Time Processes of RTPA using Real-Time Java

This paper discusses the implementation of the real-time processes of real-time process algebra (RTPA) using real-time Java. The difficulty in implementing real-time software from formal specifications comes from the fact that some realtime features expressed using a formal specification language cannot be easily transformed into a programming language. The paper shows how a combination of a real-time support library for RTPA (RTPASupportLib) and the recently developed extensions to real-time Java can overcome some of these difficulties. The strategies and techniques employed in implementing RTPA real-time features such as concurrency, interleaving, and interrupt/event/time-driven dispatching of real-time processes are presented. A number of case studies on the implementation of RTPA real-time features show that the approach is a feasible one

Implementation of the kernel techniques of real-time process algebra

This paper presents the work on developing a code generator that automatically generates C++ code based on RTPA specifications of system architecture and behaviors. The traditional sequential part of RTPA specification can be mapped onto standard C++ counterparts or their combinations. However the important real-time features of RTPA, such as interrupt, concurrency, duration, and event/time-driven cannot be dealt with the standard C++ library. In order to implement the real-time functions of RTPA, we proposed a framework which facilitates automatic C++ code generation from RTPA specifications by two phases: the first phase processes the concrete syntax of RTPA specifications resulting in the corresponding abstract syntax trees; the second phase generates code from the abstract syntax trees. In the second phrase, the RTPA runtime library is introduced to provide real-time supporting code. This paper discusses the implementation of RTPA real-time features using real-time kernel techniques to guarantee timeliness and predictability. The hardware interrupt vectoring and interrupt service routines are used to implement RTPA interrupt, timing, and duration. The multitask-scheduling techniques are used to implement RTPA concurrency. Intertask communications are adopted to implement event/time-driven processes. Experimental case studies show the real-time features of RTPA can be achieved by this approach