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...

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 model-based methodology has proven to be effective for fast and low-cost development of embedded software. In the model-based development process, transforming a software structural model that describes the underlying application, to an implementable runtime model is a critical issue. Since the designed software will finally run on the target platform, non-functional issues like schedulability, timing constraints and resource requirements have to be considered during the transformation. In this paper, we propose a generic runtime model architecture that can best satisfy the non-functional requirements of the system, and a generic transformation method to convert a structural model to a runtime model in such an architecture. The transformation approach is based on the notion of end-toend computations performed by the system in response to external stimuli. We demonstrate the advantages and effectiveness of the proposed method by constructing a software runtime model for a combined electronic throttle and airfuel ratio control system.

Preemptive multi-tasking is a commonly used architecture for designing and implementing embedded real-time software. However, preemptive multi-tasking comes with its own costs. These costs include overheads due to preemptions and context-switches that result in waste of CPU bandwidth. Also, each task incurs a memory cost largely due to the need to maintain a separate stack for each task. These costs increase with the number of tasks and can be significant in complex real-time software. In this paper, we propose results from our ongoing research in which we are developing a design method with scalable multi-tasking implementations for complex realtime software. Our design method is based on an extension of fixed priority preemptive scheduling using preemption thresholds that was proposed in [15]. Using this new scheduling model we show how we can design multi-tasking implementations that are far more scalable than using pure preemptive multi-tasking implementations. 1. Introduction P...

Abstract—Constructing runtime tasks, or operating system-level processes/threads, from the components of software design models is crucial to the model-based development of embedded control software. A better method should explore more design choices and reduce the overheads of the runtime system to meet the timing and resource constraints of embedded control software. This paper presents a novel, two-step method for systematic and automatic construction of runtime tasks from software design models. It uses graph transformation to construct a task set meeting system-level end-to-end (e2e) timing constraints. Its first step decomposes the system-level e2e timing constraints into the components ’ timing constraints, which form a necessary condition for any valid and feasible schedule. The second step iteratively merges the components into tasks and sequences their executions. A thus-constructed task set is proven to meet both intercomponent precedence and system-level e2e timing constraints and to minimize runtime overheads by minimizing the total number of resultant tasks. Our evaluation results based on randomly generated software models have shown that the proposed method outperforms commonly used methods and is also scalable. Index Terms—Task construction, model transformation, model-based design, embedded software. 1

Abstract. This paper presents an experimental evaluation of our scenario-based multithreading for real-time object-oriented models by the use of a case study of a Private Branch eXchange (PBX) system. The PBX system was taken from the industry and exhibits a number of characteristics found in real-world applications such as a highly reconfigurable dynamic structure and a typical layered architecture. The objective of this experimental study is to assess the improvements to 1) the modeling environment in terms of ease of use for designers and 2) the performance of the resultant executables. We show how our toolset was applied to the PBX system to model scenarios, as well as to generate a scenariobased multithreaded executable. The study clearly shows that our method can handle large-scale, complex models and that scenario-based multithreading achieves the performance improvements for a real-world model. 1

ROOM (Real-Time Object-Oriented Modeling) is an architecture description language widely used in the telecommunications industry to develop embedded software. The concepts of ROOM have been incorporated into the CASE tool Rational Rose Real-Time (RoseRT) in the form of a UML profile, commonly called UML-RT. However, UML-RT itself does not provide any support for performing realtime scheduling analysis and generating an implementation that meets timing constraints. It is the job of the engineer to map the software functional model to RTOS threads and choose a scheduling discipline to satisfy timing constraints. In this paper, we summarize existing approaches for implementation synthesis of UML-RT models, and describe realtime schedulability analysis technique for the native implementation model of the RoseRT CASE tool. 1.

The object-oriented design methods and their CASE 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. Task identification is usually performed in an ad-hoc manner using hints provided by human designers. In this paper, we present our ongoing research into schedulability-aware, automatic synthesis of multi-threaded implementation of a real-time object-oriented design. We present several feasible implementation strategies and architectures. We propose our approach to automatic implementation and address schedulability issues involved in our approach.

There is a general consensus on the importance of good Requirements Engineering (RE) for achieving high quality software. The modeling and analysis of requirements have been the main challenges during the development of complex systems. Although semi-formal, scenario driven approaches have raised the awareness and use of requirement engineering techniques, mostly because of their intuitive representation. Scenarios are a well established approach to describe functional requirements, uncovering hidden requirements and trade-offs, as well as validating and verifying requirements. The ability to perform quantitative analysis at the requirements level supports the detection of design errors during the early stages of a software development life cycle. Thus, it would reduce the cost of later redesign activities. In order to achieve this goal, non-functional aspects and in particular time-related aspects have to be incorporated at the software requirement phase. This is essential in order to correctly model and analyze time dependent applications at early stages in system development. The widespread interest in time modeling and analysis techniques provides the major motivation for our paper. The objective of the article is to provide readers with sufficient knowledge about existing timed scenario approaches to guide them in making informed decisions to when and how time aspects can be incorporated in their development process. In order to support this process, we present a comprehensive classification, evaluation and comparison of time-based scenario notations. In order to evaluate these existing notations, we introduce a set of eleven time-related criteria and apply them to categorize and compare forty seven scenario construction approaches.

This paper presents a systematic, schedulability-aware method for automated implementation of complex distributed real-time control systems designed with real-time object-oriented models. Our approach derives tasks in each node of a distributed system by grouping mutually exclusive transactions. It then assigns each task a feasible priority and preemption threshold. To allow for the automated analysis of the timing behavior of the derived task set, our approach exploits a schedulability analysis test based on response time analysis. This paper shows how a run-time system supporting the proposed approach is designed and how code generation is done under our framework. Our method solves the dimcult task derivation problem and enables the rapid development of distributed real-time systems.