8 research outputs found
Applying aspects to a real-time embedded operating system
The application of aspect-oriented programming (AOP) to the embedded operating system domain is still a very controversial topic, as this area demands high performance and small memory footprint. However, recent studies quantifying aspects overheads in AspectC++ show that the resource cost is very low. Therefore, operating system development may benefit with the modularization of crosscutting concerns and system specialization offered by AOP.
This paper addresses our experience in applying aspects to synchronization (mutual exclusion) and logging in a real-time embedded operating system (BOSS). Furthermore, we present our ideas for future investigation in aspect-oriented implementations for fault tolerance, middleware customization and platform variability.(undefined
Aspect-oriented programming runtime-enforcement of temporal properties in security-critical software
The Aspect-Oriented Programming paradigm has been advocated for modularisation of cross-cutting concerns in large systems. Various applications of this approach have been explored in the literature, one of which is that of runtime-verification based on assertions or temporal properties. Manually weaving temporal properties to en- sure correct execution into a large code base is difficult to achieve in a clean, modular fashion, and AOP techniques enable independent specification of the properties to be automatically woven into the code. In this paper, we explore a number of applications of AOP-based runtime- verification with an emphasis on security-critical system development. Apart from weaving properties into existing programs, we show how related techniques can be used to approach security issues separately from the functionality of a module, allowing for better design of the actual system. Also, we explore AOP as a way of automatically ensuring that reusable code in a library is temporally correctly employed. An area in which not much work has yet been done is that of the use of AOP for runtime-verification of real-time properties. In our case studies we explore real-time issues and outline a proposal for automatic translation from real-time properties into code using AOP techniques.peer-reviewe
Aspect-oriented fault tolerance for real-time embedded systems
Real-time embedded systems for safety-critical applications have to introduce fault tolerance mechanisms in order to cope with hardware and software errors. Fault tolerance is usually applied by means of redundancy and diversity. Redundant hardware implies the establishment of a distributed system executing a set of fault tolerance strategies by software, and may also employ some form of diversity, by using different variants or versions for the same processing.
This paper describes our approach to introduce fault tolerance in distributed embedded systems applications, using aspect-oriented programming (AOP). A real-time operating system sup-porting middleware thread communication was integrated to a fault tolerant framework. The introduction of fault tolerance in the system is performed by AOP at the application thread level. The advantages of this approach include higher modularization, less efforts for legacy systems evolution and better configurability for testing and product line development. This work has been tested and evaluated successfully in several fault tolerant configurations and presented no significant performance or memory footprint costs.Fundação para a Ciência e a Tecnologia (FCT
Distributed urban traffic applications based on CORBA event services
Intelligent transportation systems (ITS) in urban environments are based today on
modern embedded systems with enhanced digital connectivity and higher processing capabilities,
supporting distributed applications working in a cooperative manner. This paper provides an
overview about modern cooperative ITS equipments and presents a distributed application to
be used in an urban data network. As a case example, an application based on an embedded
CORBA-compliant middleware layer and several computer vision equipments is presented.
Results prove the feasibility of distributed applications for building intelligent urban
environments
Towards a Taxonomy of Aspect-Oriented Programming.
As programs continue to increase in size, it has become increasingly difficult to separate concerns into well localized modules, which leads to code tangling- crosscutting code spread throughout several modules. Thus, Aspect-Oriented Programming (AOP) offers a solution to creating modules with little or no crosscutting concerns. AOP presents the notion of aspects, and demonstrates how crosscutting concerns can be taken out of modules and placed into a centralized location.
In this paper, a taxonomy of aspect-oriented programming, as well as a basic overview and introduction of AOP, will be presented in order to assist future researchers in getting started on additional research on the topic. To form the taxonomy, over four-hundred research articles were organized into fifteen different primary categories coupled with sub-categories, which shows where some of the past research has been focused. In addition, trends of the research were evaluated and paths for future exploration are suggested
On Aspect-Orientation in Distributed Real-time Dependable Systems
The design and implementation of distributed real-time dependable systems is often dominated by non-functional considerations like timeliness, object placement and fault tolerance. In this paper we illustrate how the of the separation of concerns approach of aspect-oriented programming can be used to address these non-functional aspects of such system separately from the functional requirements and what benefits result from this separation. Besides the theoretical reflection we also present a case study in which distribution, timeliness, and fault tolerance aspects are added to a simple logging component. The examples are implemented using the emerging AspectC++ language for aspect-oriented programming with C++. In the course of this paper we also evaluated how well the general-purpose aspect language AspectC++ is suited to address the aspects specific to this domain
Operating system fault tolerance support for real-time embedded applications
Tese de doutoramento em Electrónica Industrial (ramo de conhecimento em Informática Industrial)Fault tolerance is a means of achieving high dependability for critical and highavailability
systems. Despite the efforts to prevent and remove faults during the
development of these systems, the application of fault tolerance is usually required
because the hardware may fail during system operation and software faults are very
hard to eliminate completely.
One of the difficulties in implementing fault tolerance techniques is the lack of
support from operating systems and middleware. In most fault tolerant projects, the
programmer has to develop a fault tolerance implementation for each application.
This strong customization makes the fault-tolerant software costly and difficult to
implement and maintain. In particular, for small-scale embedded systems, the
introduction of fault tolerance techniques may also have impact on their restricted
resources, such as processing power and memory size.
The purpose of this research is to provide fault tolerance support for real-time
applications in small-scale embedded systems. The main approach of this thesis is to
develop and integrate a customizable and extendable fault tolerance framework into a
real-time operating system, in order to fulfill the needs of a large range of dependable
applications. Special attention is taken to allow the coexistence of fault tolerance with
real-time constraints. The utilization of the proposed framework features several
advantages over ad-hoc implementations, such as simplifying application-level
programming and improving the system configurability and maintainability.
In addition, this thesis also investigates the application of aspect-oriented
techniques to the development of real-time embedded fault-tolerant software. Aspect-
Oriented Programming (AOP) is employed to modularize all fault tolerant source code, following the principle of separation of concerns, and to integrate the proposed
framework into the operating system.
Two case studies are used to evaluate the proposed implementation in terms of
performance and resource costs. The results show that the overheads related to the
framework application are acceptable and the ones related to the AOP implementation
are negligible.Tolerância a falhas é um meio de obter-se alta confiabilidade para sistemas
críticos e de elevada disponibilidade. Apesar dos esforços para prevenir e remover
falhas durante o desenvolvimento destes sistemas, a aplicação de tolerância a falhas é
normalmente necessária, já que o hardware pode falhar durante a operação do sistema
e falhas de software são muito difíceis de eliminar completamente.
Uma das dificuldades na implementação de técnicas de tolerância a falhas é a
falta de suporte por parte dos sistemas operativos e middleware. Na maioria dos
projectos tolerantes a falhas, o programador deve desenvolver uma implementação de
tolerância a falhas para cada aplicação. Esta elevada adaptação torna o software
tolerante a falhas dispendioso e difícil de implementar e manter. Em particular, para
sistemas embebidos de pequena escala, a introdução de técnicas de tolerância a falhas
pode também ter impacto nos seus restritos recursos, tais como capacidade de
processamento e tamanho da memória.
O propósito desta tese é prover suporte à tolerância a falhas para aplicações de
tempo real em sistemas embebidos de pequena escala. A principal abordagem
utilizada nesta tese foi desenvolver e integrar uma framework tolerante a falhas,
customizável e extensível, a um sistema operativo de tempo real, a fim de satisfazer às
necessidades de uma larga gama de aplicações confiáveis. Especial atenção foi dada
para permitir a coexistência de tolerância a falhas com restrições de tempo real. A
utilização da framework proposta apresenta diversas vantagens sobre implementações
ad-hoc, tais como simplificar a programação a nível da aplicação e melhorar a
configurabilidade e a facilidade de manutenção do sistema.
Além disto, esta tese também investiga a aplicação de técnicas orientadas a
aspectos no desenvolvimento de software tolerante a falhas, embebido e de tempo
real. A Programação Orientada a Aspectos (POA) é empregada para segregar em módulos isolados todo o código fonte tolerante a falhas, seguindo o princípio da
separação de interesses, e para integrar a framework proposta com o sistema
operativo.
Dois casos de estudo são utilizados para avaliar a implementação proposta em
termos de desempenho e utilização de recursos. Os resultados mostram que os
acréscimos de recursos relativos à aplicação da framework são aceitáveis e os
relativos à implementação POA são insignificantes