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.

BibTeX @book{Alexandersson2010,author={Alexandersson, Ruben},title={On Aspect-Oriented Implementation of Fault Tolerance},isbn={978-91-7385-460-3},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.},publisher={Institutionen för data- och informationsteknik, Software Engineering (Chalmers), Chalmers tekniska högskola,},place={Göteborg},year={2010},series={Doktorsavhandlingar vid Chalmers tekniska högskola. Ny serie, no: 3141Technical report D - Department of Computer Science and Engineering, Chalmers University of Technology and Göteborg University, no: 72},keywords={Aspect-Oriented Programming, Fault Tolerance, Error Detection, Fault Injection},note={180},}

RefWorks RT Dissertation/ThesisSR PrintID 128631A1 Alexandersson, RubenT1 On Aspect-Oriented Implementation of Fault ToleranceYR 2010SN 978-91-7385-460-3AB 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.PB Institutionen för data- och informationsteknik, Software Engineering (Chalmers), Chalmers tekniska högskola,T3 Doktorsavhandlingar vid Chalmers tekniska högskola. Ny serie, no: 3141Technical report D - Department of Computer Science and Engineering, Chalmers University of Technology and Göteborg University, no: 72LA engOL 30