V. De Florio

Stable memory in substation automation: a case study

In high voltage substations, electromagnetic interference results in transient faults. Typically, hardware stable storage devices are used to stabilise data, to store status information of the controller and to protect the application against these faults. A case study of electric substation automation introduced a controller distributed on a parallel architecture and substituted the stable storage device by a fault-tolerant software implementation of stable memory. This allows the application to stabilise data to ensure its integrity. Based on the combination of temporal and spatial redundancy, it tolerates permanent faults in memory and transient faults affecting computation, input and memory devices. Transient faults lead to extra cycles before data is stabilised; permanent faults can be masked or lead to reconfiguration. The flexibility of the software architecture allows to fine-tune parameters according to applications needs. This enhances reusability in wide automation areas. Evaluation confirms the suitability of the software solution during typical disturbances.

Software tool combining fault masking with user-defined recovery strategies

The voting farm, a tool which implements a distributed software voting mechanism for a number of parallel message passing systems, is described. The tool, developed in the framework of EFTOS (embedded fault tolerant supercomputing), can be used in standalone mode or in conjunction with other EFTOS fault tolerance tools. In the former case, exploitation of the mechanism is described, e.g. to implement restoring organs (N-modular redundancy systems with N-replicated voters); in the latter case, it is shown how it is possible for the user to implement in an easy and effective way a number of different recovery strategies via a custom, high-level language. Combining such strategies with the basic fault masking capabilities of the voting tool makes it possible to set up complex fault tolerant systems such as, for instance, N-and-M-spare systems or gracefully degrading voting farms. The impact that the tool can have on reliability is discussed, and it is shown how, besides structural design goals like fault transparency, the tool achieves replication transparency, a high degree of flexibility and ease-of-use, and good performance.

Methodology for refinement and optimization of dynamic memory management for embedded systems in multimedia applications

In multimedia applications, run-time memory management support has to allow real-time memory de/allocation, retrieving and processing of data. Thus, its implementation must be designed to combine high speed, low power, large data storage capacity and a high memory bandwidth. In this paper, we assess the performance of our new system-level exploration methodology to optimise the memory management of typical multimedia applications in an extensively used 3D reconstruction image system [1, 2]. This methodology is based on an analysis of the number of memory accesses, normalised memory footprint1 and energy estimations for the system studied. This results in an improvement of normalised memory footprint up to 44.2% and the estimated energy dissipation up to 22.6% over conventional static memory implementations in an optimised version of the driver application. Finally, our final version is able to scale perfectly the memory consumed in the system for a wide range of input parameters whereas the statically optimised version is unable to do this.

A hypermedia distributed application for monitoring and fault-injection in embedded fault-tolerant parallel programs

We describe a distributed, multimedia application which is being developed in the framework of the ESPRIT-IV Project 21012 EFTOS (Embedded Fault-Tolerant Supercomputing). The application dynamically sets up a hierarchy of HTML pages reflecting the current status of an EFTOS compliant dependable application running on a Parsytec CC system. These pages are fed to a World Wide Web browser playing the role of a hypermedia monitor. The adopted approach allows the user to concentrate on the high level aspects of his/her application so to quickly assess the quality of its current fault tolerance design. This view of the system lends itself well for being coupled with a tool to interactively inject software faults in the user application; this tool is currently under development.

The EFTOS voting farm: a software tool for fault masking in message passing parallel environments

We present a set of C functions implementing a distributed software voting mechanism for EPX or similar message passing environments, and we place it within the EFTOS framework (Embedded Fault-Tolerant Supercomputing) of software tools for enhancing the dependability of a user application. The described mechanism can be used for instance to implement restoring organs, i.e. modular redundancy systems with N-replicated voters. We show that, besides structural design goals like fault transparency, this tool achieves replication transparency, a high degree of flexibility and ease of use, good performance, as well as the possibility to combine fault masking with recovery techniques.

The EFTOS approach to dependability in embedded supercomputing

Industrial embedded supercomputing applications benefit from a systematic approach to fault tolerance. The EFTOS (embedded fault-tolerant supercomputing) framework provides a flexible and adaptable set of fault-tolerance tools from which the application developer can choose to make an embedded application on a parallel or distributed system more dependable. A high-level description (recovery language) helps the developer specify the fault-tolerance strategies of the application as a second application layer; this separates functional from fault-tolerance aspects of an application, thus shortening the development cycle and improving maintainability. The framework incorporates a backbone (to hook a set of fault-tolerance tools onto, and to coordinate the fault-tolerance actions) and a presentation layer (to monitor and test the fault tolerance behavior). A practical implementation is described with its performance evaluation, using an industrial case study from the energy-transport area, as well as an analytic deduction of the appropriateness of fault-tolerance techniques for various application profiles.

The TIRAN approach to reusing software implemented fault tolerance

Available solutions for fault tolerance in embedded automation are often based on strong customisation, have impacts on the whole life-cycle, and require highly specialised design teams, thus making dependable embedded systems costly and difficult to develop and maintain. The TIRAN project develops a framework which provides fault tolerance capabilities to automation systems, with the goal of allowing portable, reusable and cost-effective solutions. Application developers are allowed to select, configure and integrate in their own environment a variety of software-based functions for error detection, confinement and recovery provided by the framework.

Automated dynamic memory data type implementation exploration and optimization

The behavior of many algorithms is heavily determined by the input data. Furthermore, this often means that multiple and completely different execution paths can be followed, also internal data usage and handling is frequently quite different. Therefore, static compile time memory allocation is not efficient, especially on embedded systems where memory is a scarce resource, and dynamic memory management is the only feasible alternative. Including applications with dynamic memory in embedded systems introduces new challenges as compared to traditional signal processing applications. In this paper, an automated framework is presented to optimize embedded applications with extensive use of dynamic memory management. The proposed methodology automates the exploration and identification of optimal data type implementations based on power estimates, memory accesses and normalized memory usage.

On some key requirements of mobile application software

This paper first introduces and discusses a few considerations on some key requirements of mobile computing services. In particular, the relevance of both dependability and adaptability to an effective distribution of the service is investigated. Next, the paper discusses a novel structuring technique for the application layer of mobile software, as an example of an existing tool fulfilling those requirements. Such technique has been designed in the framework of ESPRIT project TIRAN and is fully explored in the IST project DepAuDE.

A software library, a control backbone and user-specified recovery strategies to enhance the dependability of embedded systems

Fault tolerance in embedded distributed systems requires flexibility. Solutions should be based on pre-built and reusable elements, customisable for different applications and portable to different platforms. To this end, a framework is presented, consisting of a user library, a control backbone and a high-level description language (RL). The user library contains basic functions for fault tolerance. The control layer hooks these functions together and allows to co-ordinate actions. RL allows the developer to specify the recovery strategies of the application as a sort of second application layer; this separates functional from recovery aspects of an application, shortening the development cycle and improving maintainability. This paper describes the requirements to which this framework adheres and the context in which it can be instantiated; we detail the three entities and explain how an application can be made fault-tolerant in this framework approach.