Model-based and component-oriented software development approaches are slowly superseding traditional ways of developing embedded systems. For investigating to which extent model-based development is feasible for embedded system development, we conducted a case study in which a small embedded system is developed using the MARMOT approach. In order to evaluate the degree of reuse that might be achieved, the components of the case study are used in the context of different small projects. Several aspects of reuse, application size, ease of adaptation, and development effort are quantified. This analysis reveals that model-based and component-oriented development performs well for small embedded systems, and it leads to the conclusion that model-driven/component-based development of embedded systems enables adaptable applications with higherthan- normal reuse rate. Preprint accepted for publication in 33rd EUROMICRO Conference on Software Engineering and Advanced Applications, 2007, IEEE Computer Society.

/pdf/applying-a-model-based-approach-for-embedded-system-20efvdpi81.pdf

Applying a Model-Based Approach for Embedded System Development

Model-based and component-oriented software development approaches are slowly superseding traditional ways of developing embedded systems. For investigating to which extent model-based development is feasible for embedded system development, we conducted a case study in which a small embedded system is developed using the MARMOT approach. In order to evaluate the degree of reuse that might be achieved, the components of the case study are used in the context of different small projects. Several aspects of reuse, application size, ease of adaptation, and development effort are quantified. This analysis reveals that model-based and component-oriented development performs well for small embedded systems, and it leads to the conclusion that model-driven/component-based development of embedded systems enables adaptable applications with higher- than-normal reuse rate.

/pdf/applying-a-model-based-approach-for-embedded-system-2zrvlqp7ac.pdf

Applying a Model-based Approach for Embedded System Development

Garbage collection has not been widely used in embedded real-time applications since traditional real-time garbage collection algorithm can hardly bound its worst-case responsiveness. To overcome this limitation, we have proposed a scheduling-integrated real-time garbage collection algorithm based on the single aperiodic server in our previous work. This paper introduces a new scheduling-aware real-time garbage collection which employs two aperiodic servers for garbage collection work. Our study aims at achieving similar performance compared with the single server approach whilst relaxing the limitation of the single server approach. In our scheme, garbage collection requests are scheduled using the preset CPU bandwidth of aperiodic server such as the sporadic server and the deferrable server. In the dual server scheme, most garbage collection work is serviced by the secondary server at low priority level. The effectiveness of our approach is verified by analytic results and extensive simulation based on the trace-driven data. Performance analysis demonstrates that the dual server scheme shows similar performance compared with the single server approach while it allows flexible system design.

Real-Time and Embedded Computing Systems and Applications

In this paper, we present the DIANA experiment on the use of Java in avionics safety critical applications. First, we discuss some concerns about the porting of the Java platform on the ARINC 653 operating system. Then the paper focuses on some important features of the Safety Critical Java Technology adopted in the project. Particular attention is turned on the Java memory model which is stack-based as opposed to the ongoing JSR-302 memory regions model. Benefits and issues of this approach are discussed through a real use case implementation representing part of a Flight Warning System.

Use of PERC Pico in the AIDA avionics platform

Our everyday appliances ranging from toys to vehicles, as well as the equipment used to manufacture them, contain an increasing number of embedded computers. Embedded software often implement functionality that is crucial for the operation of the device, resulting in a variety of timing requirements and resource utilization constraints to be fulfilled. Industrial competition and the ever increasing performance/cost ratio for embedded computers lead to an almost exponential growth of the software complexity, raising an increasing need for better programming languages and run-time platforms than is used today. Key concepts, such as portability, scalability, and real-time performance, have been defined, which need to be fulfilled for Java to be a viable programming language for hard real-time systems. In order to fulfill these key concepts, natively compiling Java using a revised memory management technique is proposed. We have implemented a compiler and run-time system for Java, using and evaluating new object-oriented compiler construction research tools, which enables a new way of implementing optimizations and other code transformations as a set of transforms on an abstract syntax tree. To our knowledge, this is the first implementation of natively compiled real-time Java, which handles hard real-time requirements. The new transparent garbage collector interface makes it possible to generate, or write, C code independently of garbage collector algorithm. There is also an implementation of the Java exception mechanism that can be used in conjunction with an incremental real-time garbage collector. Experiments show that we achieve good results on real-time performance, but that some work is needed to get general execution performance comparable to C++. Given our contributions and results, we do see compiled real-time Java, or a similar language such as C#, as industrially viable in a near future. (Less)

/pdf/compiling-java-for-real-time-systems-1o0tzpof1l.pdf

Compiling Java for Real-Time Systems

This paper presents the design of HIDOORS, an integrated development environment suitable for embedded distributed real-time systems, based on the Java programming language. HIDOORS will cover all the life-cycle of real-time software development with extensions to existing tools (UML modeling, Java compiler Java Virtual Machine, and a worst case execution time analysis tool) that will all be integrated into a single integrated development environment. The system will also assist the developer in distributing the application, by providing faster RMI and a distributed event manager that provides strict timing guarantees. This paper is written at the beginning of HIDOORS development, and as such, it presents only, the defined objectives and the early, architecture of the system; further developments will be the Subject of future works.

HIDOORS - a high integrity distributed deterministic Java environment

ACL2 provides a systems programming capability that allows one to write code that uses and extends ACL2 inside of ACL2. However, for soundness reasons, ACL2 bars the unrestricted use of certain kinds of programming constructs, like destructive updates, higher-order functions, eval, and arbitrary macros. We devised a methodology for writing code in Common Lisp that allows one to access ACL2, ACL2s, and Common Lisp functionality in a uniﬁed way. We arrived at this methodology in the process of developing the ACL2 Sedan (ACL2s) and using it as a key component in formal-methods-enabled projects relating to gamiﬁed veriﬁcation, education, proof checking, interfacing with external theorem provers and security. The methodology includes a library for performing ACL2 queries from Common Lisp, as well as guidelines and utilities that help address common needs. We call this methodology “ACL2s systems programming,” to distinguish it from ACL2 systems programming. We show how our methodology makes it possible to easily develop tools that interface with ACL2 and ACL2s, and describe our experience using it in our research.

ACL2s Systems Programming

Many verification and validation activities involve reasoning about constraints over complex, hierarchical data types. For example, distributed protocols are often defined using state machines that govern the behavior of processes communicating with messages which are hierarchical data types with state-dependent constraints and dependencies between component fields. Fuzzing, analyzing and evaluating implementations of such protocols requires solving complex queries that pose challenges to current SMT solvers. Generating fields that satisfy type constraints is one of the challenges and this can be tackled using enumerative data types: types that come with an enumerator, an efficiently computable function from natural numbers to elements of the type. Enumerative data types were introduced in ACL2s as a key component of counterexample generation, but they do not handle constraints such as dependencies between types. We extend enumerative data types with constraints and show how this extension enables applications such as hardware-in-the-loop fuzzing of complex distributed protocols.

A. Walter

Papers

HIDOORS - a high integrity distributed deterministic Java environment

ACL2s Systems Programming

Enumerative Data Types with Constraints