Michal Malohlava

Comparison of component frameworks for real-time embedded systems

The use of components significantly helps in development of real-time embedded systems. There have been a number of component frameworks developed for this purpose, and some of them have already became well established in this area. Even though these frameworks share the general idea of component-based development, they significantly differ in the range of supported features and maturity. This makes it relatively difficult to select the right component framework and thus poses a significant obstacle in adoption of the component-based development approach for developing real-time embedded systems. To provide guidance in choosing a component framework, or at least relevant concepts when building a custom framework, we present a survey, which illustrates distinguishing features and provides comparison of selected modern component-based frameworks for real-time embedded systems. Compared to other existing surveys, this survey focuses specifically on criteria connected with real-time and embedded systems. Further, to be practically relevant, we restrict the survey only to the frameworks that support the full development life cycle (i.e. from design till execution support). In this context, the survey illustrates the complexity of development in each framework by giving specification and code samples.

Exhaustive testing of safety critical Java

With traditional testing, the test case has no control over non-deterministic scheduling decisions, and thus errors dependent on scheduling are only found by pure chance. Java Path Finder (JPF) is a specialized Java virtual machine that can systematically explore execution paths for all possible schedulings, and thus catch these errors. Unfortunately, execution-based model checkers, including JPF, cannot be easily adapted to support real-time programs. We propose a scheduling algorithm for JPF which allows testing of Safety Critical Java (SCJ) applications with periodic event handlers at SCJ levels 0 and 1 (without aperiodic event handlers). The algorithm requires that deadlines are not missed and that there is an execution time model that can give best- and worst-case execution time estimates for a given program path and specific program inputs. Our implementation, named RSJ, allows to search for scheduling dependent memory access errors, certain invalid argument errors, priority ceiling emulation protocol violations, and failed assertions in application code in SCJ programs for levels 0 and 1. It uses the execution time model of the Java Optimized Processor (JOP). We test our tool with Collision Detector and PapaBench application benchmarks. We provide an SCJ version of the C PapaBench benchmark, which implements an autopilot that has flown real UAVs.

Property networks allowing oracle-based mode-change propagation in hierarchical components

Strong pressure on deployment of embedded control systems on a low-cost hardware leads to the need of optimizing software architectures to minimize resource demands. Nevertheless, releasing the resources not needed in specific phases of system execution is only rarely supported by todays component frameworks, mainly since information about the system state is spread over several components, which makes the idea hard to implement. The paper introduces a formal model of property networks allowing for efficient capture of modifications of architecture-relevant information and shows, how this model can be used to employ the concept of modes for system architectures in hierarchical component systems.

Constructing Domain-Specific Component Frameworks through Architecture Refinement

Recently, a plethora of domain-specific component frameworks (DSCF) emerges. Although the current trend emphasizes generative programming methods as cornerstones of software development, they are commonly applied in a costly, ad-hoc fashion. However, we believe that DSCFs share the same subset of concepts and patterns. In this paper we propose two contributions to DSCF development. First, we propose Domain Components --- a high-level abstraction to capture semantics of domain concepts provided by containers, and we identify patterns facilitating their implementation. Second, we develop a generic framework that automatically generates implementation of Domain Components semantics, thus addressing domain-specific services with one unified approach. To evaluate benefits of our approach we have conducted several case studies that span different domain-specific challenges.

Using DSL for Automatic Generation of Software Connectors

Component-based engineering is a recognized paradigm, which models an application as a collection of reusable components. The key idea behind components is that they contain only the business logic and communicate with one another only via well-defined interfaces. The communication paths among components (so called bindings) are in modern component systems realized by software connectors, which allow explicit modeling of communication and also its implementation at runtime. An important aspect of using connectors is the possibility of their automatic generation, which saves a significant amount of development work. However, the generation itself is not a trivial task, since there is a big semantic gap between the abstract specification of a connector at design time and its implementation at runtime. In this paper, we present an approach to generating implementations of software connectors. The approach is based on a new domain specific language for describing templates of connector implementations and a transformation framework using the Strate-go/XT term rewriting system for generating source code of connectors.

Component-Oriented Development for Real-Time Java

The Real-Time Specification for Java (RTSJ) offers developers an attractive platform for development of software that is composed of variously stringent real-time and non real-time tasks. However, the RTSJ introduces a programming model involving several non-intuitive rules and restrictions which make systems modeling and development a complex and error-prone task. In this chapter we introduce an advanced software engineering technology that allows developers to address these challenges – component-oriented development. In the first part, we present the general concepts and identify the key benefits of this technology. We further show one of the possible approaches on how to embrace this technology when mitigating the complexities of RTSJ development – the Hulotte framework. The framework provides a continuum between the component-oriented design and implementation process of RTSJ systems. The RTSJ concepts are treated as first-class entities which enables the modeling and automatized preparation of their implementation by employing code-generation techniques. We conclude this chapter with an extensive case study comparing object-oriented and component-oriented implementation of the Collision Detector Benchmark. Our empirical evaluation shows that the performance overhead of the framework is minimal in comparison to manually written object-oriented applications without imposing any restrictions on the programming style.

Interoperable domain‐specific languages families for code generation

This paper has been motivated by experience gained with specification and code generation of control elements for a software component platform and general‐purpose programming language like Java and C. The problem to be addressed is two‐fold: first, several domain‐specific languages (DSL) are to be employed to express different element concerns (architecture, deployment context, code pattern) and second, porting to another general‐purpose language should avoid modification of the specification and related code generation process as much as possible. In both respects, the classical template‐based code generation technique proved to be inflexible, requiring the code generator to be blurred with ad hoc encoded DSL facets. The paper addresses the problem by introducing the concept of interoperable DSL family. Each member of the family is built around its core language, which can be further specialized by embedding into a target programming language. Interoperability of these DSLs is achieved at the level of abstract syntax trees (ASTs) with help of queries. As a proof of the concept, we have implemented the queries via the AST transformation rules of the Stratego/XT framework. In the evaluation, we provide a comparison with the original template‐based implementation, which clearly indicates the DSL family and AST transformation benefits. We also provide examples of application areas where the concept of interoperable DSL family can be employed (and also indicate how this can be accomplished). Copyright

Introducing Support for Embedded and Real-Time Devices into Existing Hierarchical Component System: Lessons Learned

As embedded and real-time systems became an inherent part of many electronic appliances of everyday use, the demand for their development has grown enormously. Increasing complexity of these systems leads to demands of tools and techniques addressing their efficient and short time-to-market development. One of the possible ways to tackle the problem is a reuse of tools, methodologies and know how already established and successfully adopted in other application domains. Such transfer cannot be done inherently without appropriate modification and methodical adaptation based on an analysis of domain requirements. The paper analyzes necessary modifications and extensions of a general purpose component-based technology to enable development of embedded real-time systems. In addition, we present our own experience obtained while tailoring advanced component framework SOFA 2 to support development of embedded and real-time systems.

Automated evaluation of regular lab assignments: A bittersweet experience?

Our undergraduate curriculum includes a one semester course on object-oriented programming in the C# language and the .NET platform. The course underwent a major change in its labs organization two years ago - an introduction of regular one-week lab assignments motivated by a need to enhance unsatisfactory skills of students attending the course. However such change of the course scheme would not be possible without introduction of an automated evaluation system of the lab assignments. Besides the expected positive results, we were worried about any unforeseen consequences of the change. Having enough data from before and after the change of the course scheme the paper presents a unique analysis of impact of such a change on students and the course itself. The paper provides two main contributions: (1) to our best knowledge, we provide the first empirical validation of expected impacts on real-world data and (2) we identify and discuss several unexpected aspects and drawbacks of introduction of such a new scheme.

CoDIT: Bridging the Gap between System-Level and Component-Level Development

Component-based development traditionally recognizes two parallel views (system-level view and component-level view), which correspond to two major concerns - development of a an application and development of a reusable component for the use in application development. By having different objectives, these views have relatively disparate notion of a component, which consequently means that they are difficult (yet necessary) to combine. In this paper, we propose a method (named CoDIT), which spans the gap between the two views by providing a synchronisation between system-level view (expressed in UML 2) and componentlevel view. For component-level view, the method supports component frameworks with method-call as the communication style. The variability in the composition mechanisms of the component frameworks is addressed by using principles of metacomponent systems. The benefits of the proposed method are evaluated on a real-life case study (in SOFA 2) together with measurements of development efforts.