| 1. |
|
|
| 2. |
- Alexandersson, Ruben, 1975, et al.
(författare)
-
Aspect-Oriented Implementation of Fault Tolerance: An Assessment of Overhead
- 2010
-
Ingår i: Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics). - Berlin, Heidelberg : Springer Berlin Heidelberg. - 1611-3349 .- 0302-9743. - 9783642156502 ; 6351, s. 466-479
-
Konferensbidrag (refereegranskat)abstract
- Software-implemented fault tolerance is an attractive technique for constructing fail-safe and fault-tolerant processing nodes for road vehicles and other cost-sensitive applications. This paper investigates the memoryconsumption and execution time overhead obtained when implementing timeredundant execution and control flow checking in software for an automotive brake controller application. These two mechanisms were implemented at thesource code level using three implementations techniques: aspect-oriented programming (AOP), source code transformation and manual programming in C. The results show that AOP generates much higher overheads than codetransformation for strictly systematic implementations. On the other hand, when application knowledge is used to optimize the implementations, the overhead ofAOP is similar to that of manual programming in C.
|
|
| 3. |
|
|
| 4. |
- Alexandersson, Ruben, 1975, et al.
(författare)
-
Fault injection-based assessment of aspect-oriented implementation of fault tolerance
- 2011
-
Ingår i: 2011 IEEE/IFIP 41st International Conference on Dependable Systems and Networks, DSN 2011, Hong Kong, 27-30 June 2011. - 1530-0889. - 9781424492336 ; , s. 303-314
-
Konferensbidrag (refereegranskat)abstract
- Aspect-oriented programming provides an interesting approach for implementing software-based fault tolerance as it allows the core functionality of a program and its fault tolerance features to be coded separately. This paper presents a comprehensive fault injection study that estimates the fault coverage of two software implemented fault tolerance mechanisms designed to detect or mask transient and intermittent hardware faults. We compare their fault coverage for two target programs and for three implementation techniques: manual programming in C and two variants of aspect-oriented programming. We also compare the impact of different compiler optimization levels on the fault coverage. The software-implemented fault tolerance mechanisms investigated are: i) triple time-redundant execution with voting and forward recovery, and ii) a novel dual signature control flow checking mechanism. The study shows that the variations in fault coverage among the implementation techniques generally are small, while some variations for different compiler optimization levels are significant.
|
|
| 5. |
- Alexandersson, Ruben, 1975, et al.
(författare)
-
Fault injection‐based assessment of aspect‐oriented fault tolerance
- 2010
-
Rapport (övrigt vetenskapligt/konstnärligt)abstract
- Aspect‐oriented programming provides an interesting approach for implementing software‐based fault tolerance as it allows the core functionality of a program and its fault tolerance features to be coded separately. This paperpresents a comprehensive fault injection study that estimates the fault coverage of several software implemented fault tolerance mechanisms designed to detect or mask transient hardware faults. We compare their faultcoverage for two target programs and for three implementation techniques: manual programming in C and two variants of aspect‐oriented programming. We also compare the impact of different compiler optimization levels on thefault coverage. The software‐implemented fault tolerance mechanisms investigated are: i) triple time‐redundant execution with voting and forward recovery, ii) a novel dual signature control flow checking mechanism, and iii) anovel combination of several mechanisms that are shown to achieve perfect fault detection coverage for some of our target programs. The faults injected were single bit‐flips in memory words and instructions set architecture registers holding live data. The study shows that the variations in fault coverage among the implementation techniques generally are small, while it varies significantly (from 88% to 100%) for the different fault tolerance mechanisms.
|
|
| 6. |
|
|
| 7. |
- Alexandersson, Ruben, 1975, et al.
(författare)
-
Implementing Fault Tolerance Using Aspect Oriented Programming
- 2007
-
Ingår i: Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics). - 1611-3349 .- 0302-9743. - 9783540752936 ; 4746/2007, s. 57-74
-
Konferensbidrag (refereegranskat)abstract
- Aspect oriented programming (AOP) is a promising technique for implementing fault tolerance. Still there exist few actual implementations. One reason is that most present day AOP languages do not offer the level of control needed. This paper addresses the problem by defining a representative set of fault tolerance mechanisms. The set can be used for evaluating the feasibility of languages and for finding needs for improvements. It has been used to evaluate the AspectC++ language, and a number of limitations have been revealed. AspectC++ was then extended in order to address this. It is also demonstrated how reusable fault tolerance mechanisms can be built using aspect oriented C++, and the advantages compared to using standard C++ are discussed.
|
|
| 8. |
- Alexandersson, Ruben, 1975
(författare)
-
On Aspect-Oriented Implementation of Fault Tolerance
- 2010
-
Doktorsavhandling (övrigt vetenskapligt/konstnärligt)abstract
- This thesis investigates the use of aspect-oriented programming for the purpose of implementing fault-tolerance in software. The feasibility of aspect-oriented programming languages is evaluated from the perspectives of expressiveness, overhead, and fault coverage. It is shown that a wide range of mechanisms for fault tolerance, both systematic and application specific, can be implemented using aspect-oriented languages. Regarding overhead we show that aspect-oriented programming can be used without significant memory and run-time overhead compared to other implementation techniques. We have conducted a large fault injection study where we compare the fault coverage of aspect-oriented implementations of fault tolerance mechanisms with implementations in the C language. For the purpose of this study, we developed three software-based fault tolerance mechanisms that can detect and mask errors caused by transient hardware faults. One of these achieved perfect fault coverage in our experiments. The fault coverage of the mechanism where evaluated by injecting single-bit errors in CPU-registers and main memory locations during program execution. For each mechanism we conducted experiments with implementations made in C and two variants of the AspectC++ language. The result show that the difference in fault coverage between programs implemented using aspect-oriented programming and those implemented in C in general is small. In summary, we found clear advantages and no major disadvantages of using aspect-oriented programming for the implementation of software-based fault tolerance.
|
|
| 9. |
- Alexandersson, Ruben, 1975, et al.
(författare)
-
On hardware resource consumption for aspect-oriented implementation of fault tolerance
- 2010
-
Ingår i: EDCC-8 - Proceedings of the 8th European Dependable Computing Conference. - 9780769540078 ; , s. 61-66
-
Konferensbidrag (refereegranskat)abstract
- Software-implemented fault tolerance is a widely used technique for achieving high dependability in costsensitive applications. One approach to implementing fault tolerance in software is to use aspect-oriented programming (AOP). This paper investigates the hardware overhead imposed by software mechanisms for time-redundant execution and control flow checking implemented by using AOP. The impacts on static and dynamic memory consumption as well as execution time are measured. The overheads caused by using AOP were shown to be an issue. However, two optimizations to the weaver that reduce the overhead caused by the AOP language weaver were identified. Using these optimizations the overhead was reduced to acceptable or even beneficial levels compared to using standard C. © 2010 IEEE.
|
|
| 10. |
- Alexandersson, Ruben, 1975
(författare)
-
Techniques for software implemented fault tolerance
- 2006
-
Licentiatavhandling (övrigt vetenskapligt/konstnärligt)abstract
- Software implemented node level fault tolerance is an important technique for meeting dependability requirements in embedded safety critical systems. This thesis deals with both the issues of implementing mechanisms for fault tolerance and their validation. It is demonstrated how reusable and highly configurable fault tolerance mechanisms can be built using aspect oriented C++ and Java. The study shows that aspect oriented programming (AOP) is well suited for implementing both systematic and application specific mechanisms for node level fault tolerance. Hence a single framework for all node level fault tolerance mechanisms can be obtained. It is also shown how systematic mechanisms can be limited to only cover critical parts of the software and thereby reduce runtime overhead. Since the fault tolerance code becomes completely separated from the primary function code, AOP makes it possible to build easily applicable and reusable fault tolerance components. A framework of such components is presented and evaluated. This thesis also investigates the feasibility of emulating source code software faults directly in Java byte code for validation purposes. Experimental results show that software defects introduced in source code can be emulated in Java byte code with a high level of confidence. This makes it possible to validate the dependability of Java programs with respect to realistic software defects embedded within COTS components without the need to know the source code.
|
|
