Modeling Distributed Embedded Applications on an Interface File System Wilfried Elmenreich, Stefan Pitzek and Martin Schlager Vienna University of Technology Institut f¨ ur Technische Informatik {wil,pitzek,smartin}@vmars.tuwien.ac.at May 31, 2005 Abstract – This paper presents a framework for generic modeling of distributed embedded ap- plications. An application is decomposed into ser- vices and mapped on a set of distributed nodes, whereas each node hosts one or more services. Each service is described by four interfaces: a real- time input/output, a configuration and planning (CP), and a diagnostic and management (DM) interface. The overall application is described by a cluster configuration description that specifies the interaction of services within and across nodes. The application requirements, the service prop- erties of a node, and the interaction of the services as well as the application mapping are described formally with XML descriptions. The XML for- mat allows a language-neutral and extensible se- mantic description of interfaces supporting the implementation of context-aware tools for model- ing, scheduling, monitoring, simulation, and vali- dation. A central concept of the model is the interface file system (IFS) that acts as a distributed shared memory and transparently implements the inter- faces to services from other nodes. In principle, the communication system that updates the data in the IFS data is not bound to a specific imple- mentation as long as it fulfills the given timing requirements. The presented concepts are applied in a case study that uses the time-triggered field- bus protocol TTP/A for the implementation of a small sensor fusion application. 1 Introduction An embedded system is a computer system de- signed to perform a dedicated or narrow range of functions with minimal user intervention. By def- inition, an embedded system can be built either in a monolithic or a distributed way. In this paper we focus on distributed embedded systems. Distrib- uted embedded systems are motivated by several aspects, i. e., (i) the parts of a system, e. g., sen- sors and actuators, may be situated spatially far apart from each other (as it is the case in fac- tory and building automation), (ii) the need for parallelism (e. g., grid computing, DSP for special tasks), (iii) the need for fault tolerance (e. g., by introducing redundant nodes and channels), and, (iv) the need for a modular design (e. g., exten- sions for PCI bus). Such a distributed embedded system can be treated as a composition of several subsystems or components, whereof each component consists of a hardware and software part. The implemen- tation of these components may differ in used programming language (e. g., Assembler, VHDL, C, C++, Java), timing behavior (in terms of throughput, worst-case behavior, response time), I/O types (digital/analog, determinism, ...), and dependability (reliability, availability, maintain- ability, ...). Finding an adequate model for such systems is difficult, since on the one hand, the model must be rigid in order to describe criti- cal parameters such as timing and dependability with sufficient precision, on the other hand, due to the many different application requirements, the model should be flexible and extensible. This paper focuses on the modeling of distrib- uted embedded applications based on a descrip- tion of components in an XML-based specifica- tion language. Each service is mapped onto an Interface File System (IFS) that forms its input and output interface. Additionally, the IFS con- tains configuration and maintenance data of the subsystem, thus all state information of the sub- system is contained in the IFS. All other aspects, such as the syntactic descriptions of the informa- tion in the IFS, are mapped into an external XML description of the component. The IFS acts as a common interface that supports a unified mapping of interfaces, while the extensible XML descrip- tions provide an extensible semantic description for them. This paper is structured as follows: The next section outlines important requirements for em- bedded real-time systems. Section 3 depicts