No full-text available
To read the full-text of this research,
you can request a copy directly from the author.
A Schedulability Analyzer for Real-Time Euclid.
Abstract
A real-time language, called Real-Time Euclid, has been specifically designed with a set of schedulability analysis provisions built in. The authors introduce a set of schedulability analysis techniques that are applied to Real-Time Euclid programs and, utilizing knowledge of implementation-dependent information, provide good worst-case time bounds and other schedulability information. To demonstrate the effectiveness of these techniques, a prototype schedulability analyzer has been developed, to be used on a realistic real-time system. A description is given of the design of the prototype, and preliminary evaluation results.
... delay [0,0] ringface::transmit (node_3.box_1, 0) loop 1 max 99999 endspo { recv tokb to dummy endpro [2,2] endnod if ringface::got_tok () then node node_3 send 0 to next::next_box () delay [12,12] mailbox tokb mailbox box_1 mailbox box_2 else send 0 to next::next_box () delay [3, 3] object system endmet node node_1 method set_status (newstatus) mailbox handler_start p (mutex) [2, 3] processor proc_1 status := newstatus order program v (mutex) resource inherit endmet scheduler pripre endobj object pump sporadic interrupt semaphore mutex_pump = 1 arrival 30 chance 1 deadline 5 semaphore mutex_level = 1 offset 2 priority 1 variable status = 0 send 0 to handler_start variable water_level = 0 delay [0,0] variable tmp1 endspo variable tmp2 sporadic handler method get_status () arrival 30 trigger handler_start p (mutex_pump) deadline 20 priority 2 [1, 1] variable tmp = 0 tmp1 := status [1, 2] v(mutex_pump) recv handler_start to tmp return tmp1 environment::set_status (1) endmet pump::switch (0) method switch (newval) endspo p (mutex_pump) if newval = 1 then periodic ch4_sensor { [4, 5] period 40 deadline 25 priority 3 status := 1 [1, 2] } if environment::get_status() = 1 else then { [2, 3] { [1, 2] status := 0 if rand_10 % 5 = 1 then } environment::set_status (0) v (mutex_pump) } endmet endper method get_level () p (mutex_level) periodic water_level [1, 1] period 50 deadline 50 priority 4 tmp2 := water_level [1, 2] v (mutex_level) if rand_5 % 10 = 1 then return tmp2 pump::set_level (1) endmet endper method set_level (newlevel) p (mutex_level) periodic pump_control [2, 3] period 50 deadline 50 offset 25 water_level := newlevel priority 5 v (mutex_level) [1, 2] endmet if environment::get_status() = 0 endobj then { [2, 3] object environment if pump::get_status() = 0 && semaphore mutex = 1 pump::get_level() = 1 variable status = 1 then variable tmp pump::switch (1) } method get_status () endper p (mutex) endpro [1,2] tmp := status endnod v (mutex) endsys return tmp ...
... delay [0,0] ringface::transmit (node_3.box_1, 0) loop 1 max 99999 endspo { recv tokb to dummy endpro [2,2] endnod if ringface::got_tok () then node node_3 send 0 to next::next_box () delay [12,12] mailbox tokb mailbox box_1 mailbox box_2 else send 0 to next::next_box () delay [3, 3] object system endmet node node_1 method set_status (newstatus) mailbox handler_start p (mutex) [2, 3] processor proc_1 status := newstatus order program v (mutex) resource inherit endmet scheduler pripre endobj object pump sporadic interrupt semaphore mutex_pump = 1 arrival 30 chance 1 deadline 5 semaphore mutex_level = 1 offset 2 priority 1 variable status = 0 send 0 to handler_start variable water_level = 0 delay [0,0] variable tmp1 endspo variable tmp2 sporadic handler method get_status () arrival 30 trigger handler_start p (mutex_pump) deadline 20 priority 2 [1, 1] variable tmp = 0 tmp1 := status [1, 2] v(mutex_pump) recv handler_start to tmp return tmp1 environment::set_status (1) endmet pump::switch (0) method switch (newval) endspo p (mutex_pump) if newval = 1 then periodic ch4_sensor { [4, 5] period 40 deadline 25 priority 3 status := 1 [1, 2] } if environment::get_status() = 1 else then { [2, 3] { [1, 2] status := 0 if rand_10 % 5 = 1 then } environment::set_status (0) v (mutex_pump) } endmet endper method get_level () p (mutex_level) periodic water_level [1, 1] period 50 deadline 50 priority 4 tmp2 := water_level [1, 2] v (mutex_level) if rand_5 % 10 = 1 then return tmp2 pump::set_level (1) endmet endper method set_level (newlevel) p (mutex_level) periodic pump_control [2, 3] period 50 deadline 50 offset 25 water_level := newlevel priority 5 v (mutex_level) [1, 2] endmet if environment::get_status() = 0 endobj then { [2, 3] object environment if pump::get_status() = 0 && semaphore mutex = 1 pump::get_level() = 1 variable status = 1 then variable tmp pump::switch (1) } method get_status () endper p (mutex) endpro [1,2] tmp := status endnod v (mutex) endsys return tmp ...
... delay [0,0] ringface::transmit (node_3.box_1, 0) loop 1 max 99999 endspo { recv tokb to dummy endpro [2,2] endnod if ringface::got_tok () then node node_3 send 0 to next::next_box () delay [12,12] mailbox tokb mailbox box_1 mailbox box_2 else send 0 to next::next_box () delay [3, 3] object system endmet node node_1 method set_status (newstatus) mailbox handler_start p (mutex) [2, 3] processor proc_1 status := newstatus order program v (mutex) resource inherit endmet scheduler pripre endobj object pump sporadic interrupt semaphore mutex_pump = 1 arrival 30 chance 1 deadline 5 semaphore mutex_level = 1 offset 2 priority 1 variable status = 0 send 0 to handler_start variable water_level = 0 delay [0,0] variable tmp1 endspo variable tmp2 sporadic handler method get_status () arrival 30 trigger handler_start p (mutex_pump) deadline 20 priority 2 [1, 1] variable tmp = 0 tmp1 := status [1, 2] v(mutex_pump) recv handler_start to tmp return tmp1 environment::set_status (1) endmet pump::switch (0) method switch (newval) endspo p (mutex_pump) if newval = 1 then periodic ch4_sensor { [4, 5] period 40 deadline 25 priority 3 status := 1 [1, 2] } if environment::get_status() = 1 else then { [2, 3] { [1, 2] status := 0 if rand_10 % 5 = 1 then } environment::set_status (0) v (mutex_pump) } endmet endper method get_level () p (mutex_level) periodic water_level [1, 1] period 50 deadline 50 priority 4 tmp2 := water_level [1, 2] v (mutex_level) if rand_5 % 10 = 1 then return tmp2 pump::set_level (1) endmet endper method set_level (newlevel) p (mutex_level) periodic pump_control [2, 3] period 50 deadline 50 offset 25 water_level := newlevel priority 5 v (mutex_level) [1, 2] endmet if environment::get_status() = 0 endobj then { [2, 3] object environment if pump::get_status() = 0 && semaphore mutex = 1 pump::get_level() = 1 variable status = 1 then variable tmp pump::switch (1) } method get_status () endper p (mutex) endpro [1,2] tmp := status endnod v (mutex) endsys return tmp ...
The STRESS environment is a collection of CASE tools for analysing and simulating the behaviour of hard real-time safety-critical applications. It is primarily intended as a means by which various scheduling and resource management algorithms can be evaluated, but can also be used to study the general behaviour of applications and real-time kernels. This paper describes the structure of the STRESS language and its environment, and gives examples of its use.
... Some research is trying to enhance the predictability of real-time systems by architecture support, for example, using some kind of scheduling algorithms to guarantee the timing constrains (Gopinath and Gupta, 1990), (Liu and Ha, 1995). Some other work provides predictability analysis during compilation time, e.g., Real-Time Euclid (Stoyenko, 1987) and RTC (Ishikawa et al., 1992) provide schedulability analysis that can verify whether software adheres to its timing constraints. 1 This research has been supported by the Center for Industrial Information Technology (CENIIT), by the Volvo Research Foundation and the Volvo Educational Foundation, and by the Swedish Research Council for Engineering Sciences. ...
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.
... For embedded hard-real time systems , being able to assure that a request from the embedding environment will be served within a predefined time frame is of utmost importance. In multiprogramming environments this requirement can be expressed as schedulability: the ability to find a schedule such that each task will meet its deadline (Stoyenko , 1987) . ...
To assure temporal predictability in embeded hard real-time programing, layer-by-layer predictability of the system must be provided. Experimental hardware platform and coresponding operating system are being designed and built. Parallet to this, a programing environment for hard real-time systems is under construction, based on a simple structured programing language. A compiler with an integrated analyser for execution time analysis of tasks is used to get non-pesimistic run times.
... Being able to assure that a process will be serviced within a predefined time frame is of utmost importance. In multiprogramming environments this condition can be expressed as schedulability: the ability to find, a priori, a schedule such that each task will meet its deadline (Stoyenko, 1987). ...
Although the domain of hard real-time systems has been thoroughly elaborated in the academic sphere, embedded computer control systems — being an important component in mechatronic designs — are seldom dealt with consistently. Often, off-the-shelf computer systems are used, with no guarantee that they will be able to meet the requirements specified. In this paper, a design for embedded control systems is presented. Particularly, the paper deals with the hardware architecture and design details, the operating system, and high-level real-time language support. It is shown how estimates of process run-times necessary for schedulability analysis can be acquired on the basis of deterministic behavior of the hardware platform.
... These types of cache misses cannot be avoided if the cache has a limited size and/or set associativity. There have been many attempts to predict the WCETs of tasks 2,12,14,15,18,19]. However, most of them have not addressed the issues resulting from intra-interference in caches. ...
An accurate and reliable estimation of a task's worst case execution time (WCET) is crucial for scheduling of real-time tasks. However, instruction caches, which are extensively used in computer systems today, impose a serious problem in analyzing the WCETs of tasks. The problem stems from the fact that the cache hit or miss of an instruction reference can be known only after the worst case execution path has been found and the worst case execution path, on the other hand, can be located only after the cache hit or miss of every instruction reference is known. This cyclic dependency, in many cases, leads to a pessimistic estimation of WCETs. This paper proposes an analysis technique that is immune from the above cyclic dependency and accurately predicts the WCETs of tasks in the presence of instruction caches. The key to the proposed technique is an extension of the timing schema[16] so that the timing variation due to instruction caches can be accurately accounted for. This paper also...
... Several researchers [64,97,18] have noticed that general purpose programming languages not only do not provide timing information, such as loop bounds, but also may lead programmers to being unable to analyse the programs, such as those possibly resulting from mutually recursive function calls. Kligerman and Stoyenko [64,105] Euclid programs is also introduced in this approach. ...
... Notable exceptions are the work of Puschner within the context of the MARS project 17,24 , Park and Shaw 15,14,20,16 , Mok 12 , Woodbury 25 Sarkar 18 , and the language specific reports, e.g. Pearl 4 , and Real-Time Euclid 23,21,22,5 . The general approach adopted in this work is to split up the computations of a task into basic blocks. ...
The calculation of worst case execution time (WCET) is a fundamental requirement of almost all scheduling approaches for hard real-time systems. Due to their unpredictability, hardware enhancements such as cache and pipelining are often ignored in attempts to find WCET of programs. This results in estimations that are excessively pessimistic. In this article a simple instruction pipeline is modeled so that more accurate estimations are obtained. The model presented can be used with any schedulability analysis that allows sections of nonpreemptable code to be included. Our results indicate the WCET overestimates at basic block level can be reduced from over 20% to less than 2%, and that the overestimates for typical structured real-time programs can be reduced by 17%–40%.
Drei speziell für sicherheitsgerichtete Anwendungen konzipierte programmierbare elektronische Systeme werden vorgestellt. Das erste wird höchsten Sicherheitsansprüchen gerecht, indem seine Software die Form leicht verifizierbarer Ursache-/Wir- kungstabellen hat, die unmittelbar von der Hardware ausgeführt werden. Das zweite ist auf inhärente Unterstützung der Verifikation von Funktionsplänen mittels diversitärer Rückwärtsanalyse hin ausgelegt. Eine asymmetrische Mehrprozessorarchitektur vermeidet durch Betriebssysteme erzeugte Nichtdeterminismen mittels Migration der Funktionen des Betriebssystemkerns auf einen Koprozessor und fördert die Vorhersehbarkeit des Ausführungsverhaltens. Weiterhin wird Prozeßperipherie für zeitgenau bestimmbaren Datenaustausch beschrieben.
Nach Betrachtung eines graphischen Verfahrens zur zeitlichen Ablaufplanung und Synchronisation von Rechenprozessen werden zwei Verfahren sicherer Prozessorzuteilung für leicht vorhersagbaren Mehrprozessbetrieb vorgestellt. Das statische Verfahren aktiviert Rechenprozesse periodisch synchron zu einem Zeittakt. Synchronisierungs- und Verklemmungsprobleme lassen sich verhindern, zeitliches Ablaufverhalten vorhersagen und lastadaptiv steuern sowie Zuteilbarkeit zu jeder Zeit anhand eines einfachen Kriteriums überprüfen, indem bei der optimalen Strategie dynamischer Rechenprozesszuteilung nach Fertigstellungsfristen auf Verdrängbarkeit verzichtet wird.
For verifying timing properties of real-time distributed programs we investigate the worst-case response time of concurrent tasks which run independently but share logical or physical devices. For such tasks, a crucial factor for predicting the worst-case response time is to estimate the time spent waiting for synchronization events. We study the class of Client-Server distributed programs in which independent, time-critical tasks (Clients) are synchronized only through additional Server tasks, as recently suggested in real-time design guidelines proposed to enhance schedulability and synchronization analysis. Focussing on the timing analysis we reduce the general analysis problem to studying reduced program paths in terms of flow graphs in which the arcs are labelled with minimum and maximum execution time estimates. The first formal result shows that the problem of evaluating the worst-case waiting (blocking) time is NP-compIete. For a reduced problem version in which only operations involving communication are considered a conjecture was held that even for only 2 tasks the evaluation of the worst-case blocking time was NP-complete. We disprove this by constructing, and proving correct, a polynomial algorithm for its closed form solution which works even for an arbitrary number of tasks. The effectiveness and complexity of this algorithm are discussed, also regarding the quality of of the solutions as upper bounds for the original timing analysis problem.
The objective of this paper is to give some reflections about handling of exceptions in hard real-time environments, which is among the less elaborated topics in this domain.
A classification of possible exceptions in real-time systems is done, to identify the ones which can be prevented by certain design measures or avoided by specifying and servicing them within their contexts. A way to survive the remaining ones in a well-structured and predictable way, and as painlessly as possible, is proposed.
Timing predictability of the hard real-time systems can only be assured if every feature of them is deterministic. In this paper, various system design issues are stressed, from the system and processor architecture, to the language and exception handling. In the field of architecture, some design recommendations are given and a timing predictability study of microprocessors is carried out. Language features and exception handling are specially emphasised. For certain topics in these fields some solutions to avoid non-determinism are proposed.
Drei speziell für sicherheitsgerichtete Anwendungen konzipierte programmierbare elektronische Systeme werden vorgestellt. Das erste wird höchsten Sicherheitsansprüchen gerecht, indem seine Software die Form leicht verifizierbarer Ursache-/ Wirkungstabellen hat, die unmittelbar von derHardware ausgeführtwerden.Das zweite ist auf inhärente Unterstützung der Verifikation von Funktionsplänen mittels diversitärer Rückwärtsanalyse hin ausgelegt. Eine asymmetrische Mehrprozessorarchitektur vermeidet durch Betriebssysteme erzeugte Nichtdeterminismen mittels Migration der Funktionen des Betriebssystemkerns auf einen Koprozessor und fördert die Vorhersehbarkeit des Ausführungsverhaltens.Weiterhin wird Prozessperipherie für zeitgenau bestimmbaren Datenaustausch beschrieben.
Nach Betrachtung eines graphischenVerfahrens zur zeitlichen Ablaufplanung und Synchronisation von Rechenprozessen werden zwei Verfahren sicherer Prozessorzuteilung für leicht vorhersagbarenMehrprozessbetrieb vorgestellt. Das statische Verfahren aktiviert Rechenprozesse periodisch synchron zu einem Zeittakt. Synchronisierungs- und Verklemmungsprobleme lassen sich verhindern, zeitliches Ablaufverhalten vorhersagen und lastadaptiv steuern sowie Zuteilbarkeit zu jeder Zeit anhand eines einfachen Kriteriums überprüfen, indembei der optimalen Strategie dynamischer Rechenprozesszuteilung nach Fertigstellungsfristen auf Verdrängbarkeit verzichtet wird.
Distributed and parallel computer systems are being incorporated into real-time environments at an increasing rate. Distributed computer systems with interconnecting networks give the potential of high reliability with dynamic adaptation to modifications from the environment or internal faults. Parallel processors are ideal for the task of simulating large production plants where numerous actions and interactions simultaneously are taking place: the various real-life processes can be programmed onto different processors thus allowing a more dynamic model to be created. The multi-processor machines are ideally suited for plant monitoring, inspection or remote surveillance systems, that require virtual reality techniques, 3D graphics or complex signal processing. To guarantee that deadlines within these applications are meet, high performance obtained by the multiplicity of processors is necessary.
A typical real-time application involves the use and control of expensive equipment, possibly in situations where a missed deadline may well lead to substantial damage, including loss of human life. For many real-time systems it is thus of paramount importance that they adhere predictably to their critical timing constraints. A real-time system must be tested, analysed and checked to adhere to its critical timing constraints before the system is put in place.
We describe two languages and associated tools for capturing and analyzing two different views of the architecture of an embedded system. One language is tailored to address guidance, navigation, and feedback control issues, while the other is tailored to address real-time, fault-tolerance, secure partitioning, and scalable multiprocessor issues. Both languages have tools that perform analyses appropriate for the issues each addresses, and tools to automatically configure the application software from a sufficiently detailed specification. The integrated languages and tools are intended to support a development process based on reusing an easily configurable generic architecture developed for a family of products.
Developing a real-time system requires a balance between the timing constraints and the functional requirements. Achieving this balance often requires last-minute, low-level intervention in the code modules { via intensive hardware-based instrumentation and manual program opti-mizations. In this dissertation we present an automated, static alternative to this kind of human-intensive work. Our approach is motivated by recent advances in compiler technologies, which we extend to two speciic issues on real-time programming, that is, feasibility and schedulability. A task is infeasible if its execution time stretches over its deadline. To eliminate such faults, we have developed a synthesis method that (1) inspects all infeasible paths, and then (2) moves instructions out of those paths to shorten the execution time. On the other hand, schedulability of a task set denotes an ability to guarantee the deadlines of all tasks in the application. This property is aaected by interactions between the tasks, as well as their individual execution times and deadlines. To address the schedulability problem, we have developed a task transformation method based on program slicing. The method decomposes a task into two subthreads: the IO-handler component that must meet the original deadline, and the state-update component that can be postponed past the deadline. This delayed-deadline approach contributes to the schedulability of the overall application. We also present a new xed-priority preemptive scheduling strategy, which yields both a feasible priority ordering and a feasible task-slicing metric.
The concepts presented in this paper propose a pre-planned and integrated development process for large and complex systems which include time-critical components. A system is partitioned into subsystems which are developed relatively independently within an integration framework, but work in an integrated manner — as a “system of systems” — to provide the necessary functionality within an application domain. To do this, we propose a generic systems integration framework (GenSIF) which includes a meta-level of control and management, coordinating the independent development projects. Domain modeling, integration architecture design and infrastructures design are identified as the main elements of the proposed framework. Based on these basic concepts, a generic process model for system development and integration is presented. A possible way to handle time-critical requirements in this environment is discussed.
Abstract Rule-based programs,appear in many disguises in computer-based systems. In this thesis we address issues which arise when,the rule-based programming,paradigm is employed in the development,of reactive real-time systems. Formal techniquesare applied for the analysis of the behaviours of the rule-based programs written in RL. RL is a rule-based language which has emerged,while developing intelligent cruise control systems. The rules of RL are typical trigger-condition-action rules. An RL-based reactive system responds to discrete triggers by firing a set of rules. Such responses are activated asynchronously,and are considered instantaneous. The presence of concurrency and negation makes the behaviour of the system hard to understand. In order to understand and formally analyze the behaviour of RL programs, we first define a desired declarative semantics for responses of rule-based programs. The semantics takes a synchronousview of the changes occurring in a response while guaranteeing causality. Furthermore, it forces the consistency of concurrent assignments and un-
The following paper describes efforts to develop a processor architecture that meets the requirements of hard real time computing. The architecture is of the RISC-type with a single, modular CPU. The modules are a Kernel Processor, a Task Processor, a Memory Module and a Controller for internal and external communication. By integrating multiple register files directly accessible by the ALU, the number of main memory accesses decreases and the time for context-switches is reduced considerably. While OS functions, scheduling, time management and interrupt handling are performed by the Kernel Processor, the Task Processor focuses on its primary function, viz., to execute application program code. Assigning the traditionally sequentially performed program-, operating system- and memory-operations to different modules working in parallel results in a significant increase of performance. The reduced instruction set interfacing this architecture allows for a complete and convenient implementation of real time algorithms, especially in distributed systems, without loosing the operational determinism, which was one of the major design guidelines.
In this paper we discuss issues in real-time image processing, including applications, approaches and hardware. In particular, we discuss the failure of existing programming languages to support these considerations and present requirements for any language that can support real-time image processing.
Predictability is the crucial feature of real-time systems. It requires that all the tasks in a system meet their timing constraints. For an embedded complex system involving a number of subsystems, the timing properties of the subsystems play an important role, since the total system’s response depends on the temporal behaviour of all the subsystems. In this paper, the timing properties of reactive programs written in a rule-based language RL are analyzed. RL is a relatively simple rule language for programming the discrete part of hybrid applications, implemented using a layered architecture. The language has already been used in prototyping a complex automotive application.The upper timing bounds for RL programs, executed using either of the two evaluation strategies, have been studied. Moreover, an analysis tool has been implemented and applied to derive the timing behaviour of a non-trivial application. Some comments on the temporal behaviour of a layered system, consisting of a discrete RL program combined with a set of periodic tasks, are given.
This thesis describes the calculation of execution times in the object-oriented language RealTimeTalk (RTT). RTT is an object-oriented language for hard real-time systems. Hard real-time systems are systems where all tasks must fulfil the specified time requirements. State of the art of execution time calculation in real-time systems is presented, and the different approaches are discussed and compared to the RTT approach. RealTimeTalk (RTT) is presented. The algorithms and data structures of an implementation of execution time calculation in RTT are described. Results and some limitations in the method are discussed. Preface. This licentiate thesis is a part of a joint research project between CUS (Department of Real-time Computer Systems) at the University of Mlardalen in Vsters and the Department of Machine Elements at KTH in Stockholm. Supervisors have been Prof. Sren Andersson and Dr. Jan Wikander at the Damek research group (Computer Controlled Machinery). The work has been s...
A heuristic technique for dynamically scheduling tasks in a real-time system is described in this paper. Each task is defined by a begin time, a deadline and a required computation time. The scheduling problem is to schedule every task successfully, i.e., each task should start after its begin time and complete its execution before its deadline. Two characteristics distinguish our task model and heuristic technique: First, a new task to be scheduled is allowed to modify a previous, partial schedule that is already feasible. Thus, the heuristic technique can be used either to build a feasible schedule from scratch or extend a partial, feasible schedule. Second, each task is bounded by a window of time defined by the begin and end times. The begin time is typically equal to or greater than the task arrival time. The end time is typically equal to or less than the task deadline. The additional constraint of starting a task after specified time instant is useful in task synchronization. Comparisons with known heuristic techniques for dynamically scheduling tasks in a real-time system are made via simulation. The results show that the proposed approach has a higher degree of success in obtaining a feasible schedule compared to the other approaches.
The goals of Phase 1 are to design in detail a toolkit environment based on formal methods for the specification and verification of distributed real-time systems and to evaluate the design. The evaluation of the design includes investigation of both the capability and potential usefulness of the toolkit environment and the feasibility of its implementation.
This workshop was held May 15-17, 1991 in Atlanta, Georgia. It was the eighth in a continuing series of workshops on real-time operating systems and software and was held in conjunction with the 17th IFAC/IFIP Workshop on Realtime Programming. The workshop was co-sponsored by the IEEE Computer Society Technical Committee on Real-Time Systems and the Office of Naval Research and had as its goals: to investigate advances in real-time operating systems, software, and programming languages; to promote interaction among researchers and practitioners; to evaluate the maturity and evolutionary directions of realtime programming theories and approaches. This report contains the Proceedings of the Workshop as well as the Final Report to IEEE, the IFAC/IFIP Final Report, and additional budgetary information provided to the Office of Naval Research.
We describe a real-time software engineering toolkit called ASSERTS that provides complementary analysis and simulation capabilities to assist the real-time system designer. ASSERTS is configuration independent and allows users to describe the parameters of the hardware platform, interconnection and the kernel and the task system for the purpose of simulation and analysis. The simulation component of ASSERTS is quite detailed and features a number of built-in models for practical real-time schedulers, interconnections and resource access protocols. Users can define the behavior of the tasks at various levels of abstraction using a fairly small set of macro instructions. ASSERTS allows users to quickly gain an insight into the design of the software as it evolves and also allows "what if" studies to be done very easily.
Programs in hard real-time systems have stringent timing requirements. To ensure that the deadlines will always be met, real
time systems must be designed to have flexible performances so that they can handle variable system loads. We describe a lan
guage called Flex which makes it possible to implement real-time systems which may respond to dynamic environments. This ability to write programs
which are flexible in their execution time is facilitated by the constraint mechanism for expressing timing requirements,
and the flexible performance structures like imprecise computation and performance polymorphism. We describe the rationale behind these primitives. We also present the implementation of timing constraint and the programming
support tools.
The following article is a contribution that presents a somewhat dissenting view to the ongoing, almost ideological, dispute
between different real-time concepts and standards as realized in a language or an operating system.
Longer than in other areas of data processing, assembly languages were prevailing for the formulation of real-time applications.
The reason for this were the high prices for processors and memories enforcing optimal programming with respect to execution
time and storage utilization. However, also for developing real-time systems, the demand for high-level languages grew. The
most natural approach was to augment existing and proven languages oriented toward scientific and technical applications by
real-time features. This resulted in a large number of vendor-specific real-time dialects of FORTRAN and later also of BASIC
and a few other languages.
In real-time systems, the timing behavior is an important property of each task. It has to be guaranteed that the execution of a task does not take longer than the specified amount of time. Thus, a knowledge about the maximum execution time of programs is of utmost importance.
This paper discusses the problems for the calculation of the maximum execution time (MAXT... MAximum eXecution Time). It shows the preconditions which have to be met before the MAXT of a task can be calculated. Rules for the MAXT calculation are described. Triggered by the observation that in most cases the calculated MAXT far exceeds the actual execution time, new language constructs are introduced. These constructs allow programmers to put into their programs more information about the behavior of the algorithms implemented and help to improve the self checking property of programs. As a consequence, the quality of MAXT calculations is improved significantly. In a realistic example, an improvement fator of 11 has been achieved.
The use of embedded real-time computing systems to control industrial, medical, scientific, consumer, environmental and other
processes is rapidly growing. A failure of an embedded computing system to properly control its real-time process may lead
to major losses, possibly including the loss of human life. A real-time application thus demands from its embedded computing
system not only significant computation and control processing, but also, even more importantly, a guarantee of predictable,
reliable and timely operation.
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.
We present polynomial-time static semantics-preserving transformations of real-time programs. Used in conjunction with schedulability analysis, the transformations significantly increase the class of real-time programs that may be analyzed efficiently for guaranteed schedulability at compile-time. In cases where the form of resource contention among processes resists efficient transformation, we apply a heuristic transformation (and a consequent run-time scheduling heuristic) to allow the programs to be analyzed efficiently.
Although the domain of hard real-time systems has been thoroughly elaborated in the academic sphere, embedded computer control systems –- being an important component in mechatronic designs –- are seldom dealt with consistently. Often, off-the-shelf computer systems are used, with no guarantee that they will be able to meet the requirements specified. In this paper, a design for embedded control systems is presented. Particularly, the paper deals with the hardware architecture and design details, the operating system, and high-level real-time language support. It is shown how estimates of process run-times necessary for schedulability analysis can be acquired on the basis of deterministic behavior of the hardware platform.
The timing predictability of hard real-time systems can only be
assured if every component behaves deterministically. Various system
design issues are stressed, from system and processor architecture to
language and exception handling. In the field of architecture, some
design recommendations are given and a timing predictability study of
microprocessors is carried out. For certain topics in these fields,
solutions to avoid nondeterminism are proposed
This paper discusses how the timing constraints, which represent the timimg characteristics that computations in a real-time system must satisfy, are implemented in Flex. An implementation scheme of these timing constraints is presented. We also discuss briefly the interactions between constraints and the consistency checking to be conducted at the compile time.
Accurate schedulability analysis of real-time programs, even in a language such as Real-Time Euclid, is NP-complete, essentially due to the exponential number of possible execution paths. Most of the exponential growth in the path space explored by the analysis is attributable to conditional statements in the programs. The paper presents two techniques using additional static information to improve significantly the cost of a typical schedulability analysis: the first detects non-executable paths by linking execution of conditional branches in different parts of the program; the second considers the branches of a single conditional, and eliminates paths by transforming conditional branches which cannot result in worst-case timing behavior. Each link or transformation can reduce the number of alternate paths the residual analysis has to consider by a factor of 2, thus allowing schedulability analysis to be practically applied to large real-time programs. An experimental evaluation of the techniques applied to both computer-generated and real programs indicates the value of this approach.
To ensure temporally predictable execution behaviour of an embedded hard real-time computer control system, layer-by-layer predictability of the system must be provided. Based on a simple structured programming language, a programming environment for hard real-time applications is under construction designed to function temporally predictably, and to support an experimental hardware platform as well as a corresponding operating system. A compiler with an integrated analyser for execution-time analysis of tasks is used to determine usable, realistic and not too pessimistic run-time estimates.
Real-time computing applications are among the very earliest of all computing applications, and their use continues to grow at a rapid pace after 40 years. Many programming languages have been used to develop today's real-time software. We attempt to define appropriate requirements for a real-time language and undertake a chronological survey and assessment of languages representative of the many real-time languages designed and used. Following the survey, we draw conclusions and speculate on what future real-time language work may or should bring.
We present techniques to support the construction of parallel, embedded systems from reusable software components. Specifically, we describe accurate and efficient performance prediction functions for processes and objects that have been assigned to processing elements (PEs) in parallel systems. The functions (1) consider load-balancing, parallelism and deadlines, (2) predict performance on the basis of projected service rates, and (3) treat PEs and communication links in an integrated manner. A quantitative evaluation has demonstrated that the functions perform well.
This paper discusses issues in real-time image-processing, including applications, approaches, and hardware. In particular, the failure of existing programming languages to support these considerations, and present requirements for any language that can support real-time image-processing are discussed.
According to e.g. Parnas [1], reactive systems can be modeled very conveniently using an action-event paradigm. According to this paradigm a system is assumed to be build around a state, events causing the system to modify this state. In this paper we describe a simple language, SEAL, (SEAL is an acronym for Seal: an Experimental Action-event Language) for prototyping systems which have been described in the form of action-event specifications. The language has been used for modelling some simple problems; our current activities encompass an improved implementation that allows some analysis on the statical program text.
Research in Worst-Case Execution-Time (WCET) analysis aims at integrating WCET analysis with program compilation, thus increasing compiler complexity and forcing real-time software developers to use specific compilers. This paper describes a simple approach to WCET analysis that is not compiler-specific: A software tool reads the path information contained in source programs and maps this information onto the respective assembler programs. A low-level WCET analysis tool then computes detailed timing information of the annotated assembler programs, and passes the information back to the source level. Experiments demonstrate the feasibility of the approach.
The overhead of the general checkpointing approach is infeasible
for distributed real-time systems where timing is critical. We present a
new compiler based approach which classifies data, and minimizes the
data needed for checkpointing using static data flow analysis and
language support. Our approach provides static guarantees of timeliness
while checkpointing, and explores timely recovery for real-time systems.
We outline our approach and discuss the necessary architecture and
language support needed to make this feasible
Engineering of complex distributed real-time applications is one
of the hardest tasks faced by the software profession today. All aspects
of the process, from design to implementation, are made more difficult
by the interaction of behavioral and platform constraints. Providing
tools for this task is likewise not without major challenges. In this
paper, we discuss a tool suite at New Jersey Institute of Technology's
Real-Time Computing Lab which supports the development of complex
distributed real-time applications in a suitable high-level language
(CRL). The suite's component tools include a compiler, a
transformer-optimizer, an allocator-migrator, schedulability analyzers,
a debugger-monitor, a kernel, and a (simulated) network manager. The
overall engineering approach supported by the suite is to provide as
simple and natural an integrated development paradigm as possible. The
suite tools address complexity due to distribution, scheduling,
allocation and other sources in an integrated manner (largely)
transparent to the developer. To reflect the needs of propagation of
functional and non-functional requirements throughout the development
process, a number of robust code transformation and communication
mechanisms have been incorporated into the suite. To facilitate
practical use of the suite, the developed programs compile-transform to
a safe subset of C++ with appropriate libraries and runtime
support
ResearchGate has not been able to resolve any references for this publication.