The maturity of schedulabilty analysis techniques for fixed-priority preemptive scheduling has enabled the consideration of timing issues at design time using a specification of the tasking architecture and estimates of execution times for tasks. While successful, this approach has limitations since the preemptive multi-tasking model does not scale well for a large number of tasks, and the fixed priority scheduling theory does not work well with many object-oriented design methods. In this paper we present an approach that uses a scalable implementation architecture where design level tasks are grouped into a smaller number of run-time threads during implementation. The schedulability analysis for this implementation architecture is based on the preemption threshold scheduling model. We show that our approach provides significant advantages over one using fixed-priority preemptive scheduling architecture. The benefits include higher schedulability for small number of tasks, and lower r...

The increasing complexity of real-time software has led to a recent trend in the use of high-level modeling languages for development of real-time software. One representative example is the modeling language ROOM (real-time object-oriented modeling), which provides features such as object-orientation, state machine description of behaviors, formal semantics for executability of models, and possibility of automated code generation. However, these modeling languages largely ignore the timeliness aspect of real-time systems, and fail to provide any guidance for a designer to a priori predict and analyze temporal behavior. In this paper we consider schedulability analysis for automated implementations of ROOM models, based on the ObjecTime toolset. This work builds on results presented in [8], where we developed some guidelines for the design and implementation of real-time object-oriented models. Using the guidelines, we have modified the run-time system library provided by the ObjecTime...

In this paper we present an approach towards automatic synthesis of implementations from real-time objectoriented design models. From an application design model that addresses the functional requirements of the system, and given end-to-end timing requirements, our synthesis approach generates a feasible implementation model, i.e., one that will meet the timing requirements. The synthesis process is supported by automatic code-generation that can take the application design model and the synthesized implementation model, and can generate code for the target platform. The synthesis of an implementation model is facilitated through the use of a generic (application independent) implementation architecture; thereby reducing the synthesis problem to selecting a mapping of the application design model to the artifacts of the implementation architecture. In this paper we use a multi-threaded event handling architecture with fixed event priorities. The synthesis problem then consists of deter...

There is a growing interest in using the object paradigm for developing real-time software. We believe that an approach that integrates the advancements in both object modeling and design methods, and real-time scheduling theory is the key to successful use of object technology for real-time software. Surprisingly many past approaches to integrate the two either restrict the object models, or do not allow sophisticated schedulability analysis techniques. In this paper we show how schedulability analysis can be integrated with object-oriented design. More specifically, we show how fixed priority scheduling theory can be applied to designs developed using UML-RT, a specialization of UML for real-time software. We show how a design model built with active objects, and asynchronous and synchronous message passing (as is the case in UML-RT) can be implemented such that the implementation can be analyzed for schedulability. We then develop the response time analysis for such implementations,...

The design of a real-time system must not only incorporate means of tackling functionalcomplexity, but also means to analyze and predict real-time temporal properties. Unfortunately, most design methods provide little support to a designer towards meeting the real-time performance specifications of the system. The design of a system involves many parameters which are artifacts of the system design, and for a given system may be chosen in many different ways to meet the performance requirements of a system. In this paper, I present a summary of recent research work that is aimed at developing a set of techniques that can be used by a designer in choosing design artifacts such as periodicities, deadlines, priorities, etc. so as to design a system that will predictably satisfy the performance specifications. We expect that the techniques presented in this paper will help reduce the laborious process of designing a real-time system, by bringing resource contention and schedulability aspect...

tools are widely used in practice by many real-time software developers. However, object-oriented CASE tools require an additional step of identifying tasks from a given design model. Unfortunately, it is difficult to automate this step for a couple of reasons: (1) there are inherent discrepancies between objects and tasks; and (2) it is hard to derive tasks while maximizing real-time schedulability since this problem makes a non-trivial optimization problem. As a result, in practical objectoriented CASE tools, task identification is usually performed in an ad-hoc manner using hints provided by human designers. In this paper, we present a systematic, schedulability-aware approach that can help mapping real-time object-oriented models to multi-threaded implementations. In our approach, a task contains a group of mutually exclusive transactions that may possess different periods and deadline. For this new task model, we provide a schedulability analysis algorithm. We also show how the run-time system is implemented and how executable code is generated in our framework. We have performed a case study. It shows the difficulty of task derivation problem and the utility of the automated synthesis of implemenation.

In this paper we argue that a programming language for real-time systems should support the declaration of timeconstraints, and that those constraints should attach to a well-developed notion of reactions. To make our claims more precise, we introduce Timber, which is a concurrent programming language based on a model of non-blocking, reactive objects. Timber supports both upper and lower time constraints on a reaction, where an upper constraint corresponds to a classical deadline, and a lower constraint constitutes a very efficient way of scheduling an event to occur at a well-defined point in the future. A series of programming examples illustrates how these mechanisms can be used to express simple solutions to common problems in practical real-time programming. 1.

We present a coordination language and its semantics for specification and implementation of object-oriented realtime systems. Real-time systems operate under real-time constraints, and our language supports expression thereof. In our language, a system is modeled by two separate but complementary descriptions: A collection of objects define the system's structure and functional behavior, and a set of interaction constraints define how these objects may interact. Our language thereby supports development of realtime systems by enabling objects build in isolation or reused from other systems to be composed via interaction constraints. We use the Actor model to describe objects and the concept of real-time synchronizers to describe interaction constraints. Our model is accompanied by a formal semantics that precisely defines what real-time constraints means, and what constitutes a program's correct real-time behaviors. The semantics defines how the system may evolve in the real-time doma...

Large and complex real-time systems can benefit significantly from a component-based development approach where new systems are constructed by composing reusable, documented and previously tested concurrent objects. However, reusing objects which execute under real-time constraints is problematic because application specific time and synchronization constraints are often embedded in the internals of these objects. The tight coupling of functionality and real-time constraints makes objects interdependent, and as a result difficult to reuse in another system.

This paper discusses a model-based design flow for requirements in distributed embedded software development. Such requirements are specified using a language similar to Linear Temporal Logic which allows one to reason about time and sequencing. They consist of assertions which must hold for a design, given some assumptions on its environment. They can be checked both during simulation and, at least for a subset, even on the target. The key contribution of the paper is the extension to the embedded software domain of assertion-based verification, and the automated generation of property-checking code in multiple target languages, from simulation, to prototyping, to final production. 1.