Doubling the engineer's utility

The big challenge for military forces and their industrial supporters since the end of the cold war is how to convert technologies once viewed as exclusively military to serve civilian ends as well. The authors discuss a case of dual use in which a rigorous military method for designing complex computer systems appears suited to complicated civilian projects. The method is supported by a new language, CaRT-Spec, which is application independent and therefore suitable for both military and civilian applications     

Development and integration of a concurrently executing interactive user interface for the I-STAT protable clinical analyzer: A case study in real-time systems integration

A novel real-time scheduler was developed to implement an interactive user interface for an existing state-of-the-art, hand-held blood analyzer. A software-timer-based scheduler was designed and implemented and guaranteed schedulability analysis performed to ensure that all hard execution deadlines could be met at run time. An execution bandwidth preservation mechanism that increases the robustness and predictability of the scheduler is presented. The paper is a case study that describes the design and development process from a point of view that emphasizes the importance of the systems integration issues that were encountered.     

A description language for engineering of complex real-time systems

Typical in modern complex real-time applications are (1) integration of lar ge systems, as well as development of new systems and subsystems, (2) complex, often conflicting, functional and non-functional objectives, and (3) a significant degree of distribution and parallelism. The article takes a particular approach to viewing such applications, and describing them in a new language, called CaRT-Spec. While CaRT-Spec addresses many complex application objectives, the focus of our presentation is on functionality and timeliness, i.e. schedulability.     

Comparative evaluation of high-level real-time programming languages

Owing to the fast growing need for better means of building real-time systems, a number of representative languages used in real-time programming is surveyed. The evaluation focuses on seven languages which possess explicit real-time features. Based on a categorization of the latter, the seven languages are then compared with respect to their real-time capabilities. The strong points and the limitations of Ada and PEARL, the only high-level real-time languages readily applicable in industrial control environments, are covered in more detail. The evaluation reveals that none of the languages actually used in industry is genuinely real-time. Therefore, a number of new features is suggested for incorporation into existing or future languages and their run-time environments. These proposals are meant to advance the inadequate state of affairs, and also to reignite the discussion of this topic in the real-time community.     

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     

Supra-RPC: Subprogram parameters in remote procedure calls

Remote-procedure calls (RPCs) allow distributed, high-level language programs to communicate and synchronize in the usual manner via subprogram calls. One of the great challenges in RPC research is to preserve the traditiional call semantics despite the distribution and heterogeneity of the new environment. The main contribution of SUPRA-RPC is in addressing the passing of subprograms as RPC parameters. In doing so, SUPRA overcomes a number of technical difficulties, stemming from scoping, side-effects and other sources. Since supporting subprogram RPC parameters is harder than supporting non-subprogram RPC parameters, the three (of six) components of the SUPRA architecture extend in novel ways the traditional functionality found in their counterparts in other RPC systems. The SUPRA stub generator extracts information not only from remote entry interfaces, but from any scope potentially referenced by a subprogram passed as an RPC parameter. In addition to the usual call- and accept-stubs and the marshaling and unmarshaling routines, the generator constructs out-of-scope access stubs, callback' and callback-handling-stubs, and modified parameter subprograms and others. The SUPRA run-time support manages a run-time symbol table to keep track of referencing environments and out-of-scope objects. When an out-of-scope object is unavailable for access or execution on the server, the object is reached by a synchronous, ‘under-the-covers’ callback. The SUPRA process management supports servers with independent threads of control, manages (possibly nested) callbacks and pools of callback handler threads, and maintains correct identification of thread-initiated calls or callbacks. A SUPRA prototype has been implemented on Sun Unix workstations. The prototype supports C, C++ and CommonLisp programs. A prototype graphical demonstration has been implemented as well, that represents RPC concepts in terms of common life objects and situations.     

Engineering complex computer systems: a challenge for computertypes everywhere. I. Let's agree on what these systems are

We define the engineering of complex computer systems as all activities pertinent to specifying, designing, prototyping, building, testing, operating, maintaining, and evolving complex computer systems. While in the past, relatively noncomplex traditional systems sufficed for most computer control applications, the new and emerging demands of applications and the evolution of computer architectures and networks now essentially force systems to be complex, given our current understanding of how to engineer these systems. Complex computer systems are found in almost every industry. These include industrial process control, aerospace and defence, transportation and communications, energy and utilities, medicine and health, commercial data processing, and others. Unfortunately, the state of the art in research and technology has clearly fallen far behind the requirements of industrial, commercial, and government complex computer systems     

Load Balanced Mapping of Distributed Objects to Minimize Network Communication

This paper introduces a new load balancing and communication minimizing heuristic used in theInverse Remote Procedure Call(IRPC) system. While the paper briefly describes the IRPC system, the focus is on the newIRPCassignment heuristic. The IRPC compiler maps a distributed program to a graph that represents program objects and their dependencies (due to invocations and parameter passing) as nodes and edges, respectively. In the graph, the system preserves conditional and iterative flows, records network transmission and execution costs, and marks nodes that have to reside at specific network sites. The graph is then partitioned by the heuristic to derive a (sub)optimal node assignment to network sites minimizing load balancing and network data transport. The resulting program partition is then reflected in the physical object distribution, and remote and local object communication is transparently implemented. The compiler and run-time system use efficient implementation techniques such as type prediction, inlining, splitting and subprogram passing. The last of these allows remote code to be copied to local data, as an alternative to copying data to the remote site, whenever this will reduce network data transport. The IRPC graph partitioning heuristic operates in timeO(E(logd+l+ logM)), whereMis the number of network sites,Eis the number of communication edges, anddis the maximum degree of a node;lis a parameter of the algorithm, and can vary between 1 andN, whereNis the number of communicating objects. This complexity is more nearly independent ofM, and considerably better in terms ofEandN, than that of previously known related algorithms, such as A*, which employs backtracking and is potentially exponential, or the max-flow/min-cut class of network flow algorithms or heuristics which tend to be at least of Ω(MN²E), and it can be made (by choosinglappropriately) as efficient as even such fast heuristics as heaviest-edge-first, minimal communication, and Kernighan–Lin. In an extensive quantitative evaluation, the heuristic has been demonstrated to perform very well, giving on the average 75% traffic cost reductions for over 95% of the programs when compared to random partitioning, and outperforming in cost reduction and actual execution time the three aforementioned fast heuristics, even with a largel. Thus, to the best of our knowledge, this is the first report of a well-performing assignment heuristic that is bothessentially linearin the number of communication edges, andbetterthan existing, established heuristics of no better complexity.