Compositional semantics of a real-time prototyping language

The formal semantics of a prototyping language for hard real-time systems, PSDL, is given. PSDL provides a data flow notation augmented by application-orientation timing and control constraints to describe a system as a hierarchy of networks of processing units communicating via data streams. The semantics of PSDL are defined in terms of algebraic high-level Petri nets. This formalism combines algebraic specifications of abstract data types with process and concurrency concepts of Petri nets. Its data abstraction facilities are used to define the meaning of PSDL data types, while high-level Petri nets serve to model the casual and timing behavior of a system. The net model exposes potential concurrency of computation and makes all synchronization needs implied by timing and control constraints explicit and precise. Time is treated as state of clocks, and clocks are modeled as ordinary system components. The net semantics provides the basis for applying analysis techniques and semantic tools available for high-level Petri nets     

Automated prototyping tool-kit (APT)

Automated prototyping tool-kit (APT) is an integrated set of software tools that generate source programs directly from real-time requirements. The APT system uses a fifth-generation prototyping language to model the communication structure, timing constraints, I/O control, and data buffering that comprise the requirements for an embedded software system. The language supports the specification of hard real-time systems with reusable components from domain specific component libraries. APT has been used successfully as a research tool in prototyping large war-fighter control systems (e.g. the command-and-control station, cruise missile flight control system, patriot missile defense systems) and demonstrated its capability to support the development of large complex embedded software.     

Extending Pearl for industrial real-time applications

High-Integrity Pearl, (HI-Pearl) an extension to the Process and Experiment Automation Real-Time language (Pearl) which incorporates several principles from the real-time Euclid language, is described. The requirements of real-time software and components of a real-time language are reviewed. HI-Pearl's mechanisms for concurrency control, synchronization, allocation, time-bounded loops, surveillance of events, parallelism, timing constraints, overload detection and handling, storage management, run tracing, and error detection and handling are discussed. HI-Pearl's schedulability analyzer, an automated tool to predict whether real-time software will adhere to its critical timing constraints, is also discussed     

Semi-automated architectural abstraction specifications for supporting software evolution

In this paper we present an approach for supporting the semi-automated architectural abstraction of architectural models throughout the software life-cycle. It addresses the problem that the design and implementation of a software system often drift apart as software systems evolve, leading to architectural knowledge evaporation. Our approach provides concepts and tool support for the semi-automatic abstraction of architecture component and connector views from implemented systems and keeping the abstracted architecture models up-to-date during software evolution. In particular, we propose architecture abstraction concepts that are supported through a domain-specific language (DSL). Our main focus is on providing architectural abstraction specifications in the DSL that only need to be changed, if the architecture changes, but can tolerate non-architectural changes in the underlying source code. Once the software architect has defined an architectural abstraction in the DSL, we can automatically generate architectural component views from the source code using model-driven development (MDD) techniques and check whether architectural design constraints are fulfilled by these models. Our approach supports the automatic generation of traceability links between source code elements and architectural abstractions using MDD techniques to enable software architects to easily link between components and the source code elements that realize them. It enables software architects to compare different versions of the generated architectural component view with each other. We evaluate our research results by studying the evolution of architectural abstractions in different consecutive versions of five open source systems and by analyzing the performance of our approach in these cases.     

Extension Language Automation of Embedded System Debugging

Embedded systems contain several layers of target processing abstraction. These layers include electronic circuit, binary machine code, mnemonic assembly code, and high-level procedural and object-oriented abstractions. Physical and temporal constraints and artifacts within physically embedded systems make it impossible for software engineers to operate at a single layer of processor abstraction. The Luxdbg embedded system debugger exposes these layers to debugger users, and it adds an additional layer, the extension language layer, that allows users to extend both the debugger and its target processor capabilities. Tcl is Luxdbg's extension language. Luxdbg users can apply Tcl to automate interactive debugging steps, to redirect and to interconnect target processor input-output facilities, to schedule multiple processor execution, to log and to react to target processing exceptions, to automate target system testing, and to prototype new debugging features. Inclusion of an extension language like Tcl in a debugger promises additional advantages for distributed debugging, where debuggers can pass extension language expressions across computer networks.     

基于构件的嵌入式实时软件建模与分析

嵌入式实时软件具有严格的时间要求,任何时间错误都可能造成重大的经济损失甚至导致灾难性的后果。因此,在软件开发早期,对其时间需求进行形式化的分析和验证是非常重要的。本文提出一种基于构件的嵌入式实时软件建模与分析方法,该方法不仅可以检测出需求模型中的时间冲突,有助于保证嵌入式实时软件时间约束的正确性,而且也也使得分析结果具有可复用、可扩展的优点。     

User-defined schedulers for real-time concurrent objects

Scheduling concerns the allocation of processors to processes, and is traditionally associated with low-level tasks in operating systems and embedded devices. However, modern software applications with soft real-time requirements need to control application-level performance. High-level scheduling control at the application level may complement general purpose OS level scheduling to fine-tune performance of a specific application, by allowing the application to adapt to changes in client traffic on the one hand and to low-level scheduling on the other hand. This paper presents an approach to express and analyze application-specific scheduling decisions during the software design stage. For this purpose, we integrate support for application-level scheduling control in a high-level object-oriented modeling language, Real-Time ABS, in which executable specifications of method calls are given deadlines and real-time computational constraints. In Real-Time ABS, flexible application-specific schedulers may be specified by the user, i.e., developer, at the abstraction level of the high-level modeling language itself and associated with concurrent objects at creation time. Tool support for Real-Time ABS is based on an abstract interpreter that supports simulations and measurements of systems at the design stage.     

Documenting electronic commerce systems and software using the unified modeling language

Electronic commerce (EC) systems are complex systems consisting of cooperating heterogeneous software, hardware and database subsystems that are distributed among processing nodes [1]. They are reactive, real-time and concurrent distributed systems. They are financially critical systems since they perform distributed business functions, the success of which is very critical for the business operation. The use of well-defined specification and documentation techniques is very essential for the effective development and maintenance of these systems. In this paper, we propose the use of the unified modeling language (UML) [2] as a technique for documenting and specifying EC systems at various levels of abstractions and from different views. We believe that the use of UML ensures a better reliability and reusability of these systems.     

Parents are shared parts of objects: Inheritance and encapsulation in SELF

The design of inheritance and encapsulation in SELF, an object-oriented language based on prototypes, results from understanding that inheritance allows parents to be shared parts of their children. The programmer resolves ambiguities arising from multiple inheritance by prioritizing an object's parents. Unifying unordered and ordered multiple inheritance supports differential programming of abstractions and methods, combination of unrelated abstractions, unequal combination of abstractions, and mixins. In SELF, a private slot may be accessed if the sending method is a shared part of the receiver, allowing privileged communication between related objects. Thus, classless SELF enjoys the benefits of class-based encapsulation.This work has been generously supported by National Science Foundation Presidential Young Investigator Grant #CCR-8657631, and by Sun Microsystems, IBM, Apple Computer, Cray Laboratories, Tandem Computers, NCR, Texas Instruments, and DEC.     

A framework for evaluating the effectiveness of real-time object-oriented models

The design of a real-time system needs to incorporate methods specifically developed to represent the temporal properties of the system under consideration. Real-time systems contain time and event driven actions. Structured design methods provided a reasonable set of abstractions for design of time and event driven factors in real-time designs. As program complexity, size, and time to market pressure grows, the real-time community migrated towards object-oriented technology. Evidence suggests that object-oriented technology in non-real-time systems is most effective in abstraction, modeling, implementation, and reuse of software systems. Many design models and methods exist for object-oriented real-time designs. However, the selection process of a model for a particular application remains a tedious task. This paper introduces an analysis framework that can be applied to a design model to evaluate its effectiveness according to desired performance specifications. To illustrate our approach, we present a case study using the popular automotive cruise control example on two real-time object-oriented models.     

The impact of distributed programming abstractions on application energy consumption

With battery capacities remaining a key physical constraint for mobile devices, energy efficiency has become an important software design consideration. Distributed programming abstractions (e.g., sockets, RPC, messages, etc.) are an essential component of modern software, but their energy consumption characteristics are poorly understood. The programmer has few practical guidelines to choose the right abstraction for energy-constrained scenarios. In this article, we report on the findings of a systematic study we conducted to compare and contrast major distributed programming abstractions in terms of their energy consumption patterns. By varying the abstractions with the rest of the functionality fixed, we measure and analyze the impact of distributed programming abstractions on application energy consumption. Based on our findings, we present a set of practical guidelines for the programmer to select an abstraction that satisfies the energy consumption constraints in place. Our other guidelines can steer future efforts in creating energy efficient distributed programming abstractions.     

Enabling fuzzy technologies in high performance networking via an open FPGA-based development platform

Soft computing techniques and particularly fuzzy inference systems are gaining momentum as tools for network traffic modeling, analysis and control. Efficient hardware implementations of these techniques that can achieve real-time operation in high-speed networking equipment as well as other highly time-constrained application fields is however an open problem. We introduce a development platform for fuzzy inference systems with applications to network traffic analysis and control. The platform addresses the current requirements and constraints of high performance networking equipment. For the development process, we set up a methodology and a CAD tool chain that span the entire design process from initial specification in a high-level language to implementation on FPGA devices. An FPGA development board with PCI/PCIe interface is employed to support an open platform that comprises CAD tools as well as IP cores. PCI compatible fuzzy inference modules are implemented as System-on-Programmable-Chip (SoPC). We present satisfactory experimental results from the implementation of fuzzy systems for a number of applications in analysis and control of Internet traffic. These systems are shown to satisfy operational and architectural requirements of current and future high performance routing equipment. The platform proposed allows for the development of prototypes while avoiding large investments and complicated management procedures which constrain the testing and adoption of soft computing techniques in high performance networking.     

Models and temporal logical specifications for timed component connectors

Component-based software engineering advocates construction of software systems through composition of coordinated autonomous components. Significant benefits of this approach include software reuse, simpler and faster construction, enhanced reliability, and dramatic reductions in the complexity of construction of provably correct critical systems, many of which involve real-time concerns. Effective, flexible component composition by itself still poses a challenge today and yet the special nature of real-time constraints makes component-based construction of real-time systems even more demanding. The coordination language Reo supports compositional system construction through connectors that exogenously coordinate the interactions among the constituent components which unawarely comprise a complex system, into a coherent collaboration. The simple, yet surprisingly rich, calculus of channel composition that underlies Reo offers a flexible framework for compositional construction of coordinating component connectors with real-time properties. In this paper, we present an operational semantics for the channel-based component connectors of Reo in terms of Timed Constraint Automata and introduce a temporal-logic for specification and verification of their real-time properties.      

IAda: A language for robot programming based on Ada

We present a programming language for robots which we have implemented based on the Ada language. It is an interpreted language which permits dynamic configuration of software. It manipulates Ada tasks and subroutines. One of the Ada tasks is an inference engine of a logic programming language adapted to real-time constraints. We show how the conjunction of Ada tasks, to perform perception and action functions on the robot, to logic programs, for the control of these tasks, both manipulated by the IAda language, gives a powerful environment for robot programming.     

What's ahead for embedded software?

Once deemed too small and retro for research, embedded software has grown complex and pervasive enough to attract the attention of computer scientists. There are many research questions, but most center around one issue: how to reconcile a set of domain-specific requirements with the demands of interaction in the physical world. How do you adapt software abstractions designed merely to transform data to meet requirements like real-time constraints, concurrency, and stringent safety considerations? The answer to this question has given rise to some promising research angles, including novel ways to deal with concurrency and real time and methods for augmenting component interfaces to promote safety and adaptability