Implementing Fault Tolerance Using Aspect Oriented Programming

Alexandersson, Ruben

doi:10.1007/978-3-540-75294-3_6

Cited by 10 publications

(11 citation statements)

References 9 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The extensions consist of joinpoints for variable read and write operations, as well as extra reflexive information about targeted functions. These features are commonly found in other AOP languages and are described in detail in [4]. For this study one small addition to the language was needed as well.…”

Section: Aspectc++ Implementationmentioning

confidence: 97%

“…Apart from the language extensions, we also present AOP implementations of several fault tolerance mechanisms including time-redundant execution and control flow checking in [4]. The control flow checking implementation used in this study is similar to the one presented there with the exception that no stack is used.…”

Section: Aspectc++ Implementationmentioning

confidence: 97%

“…Hence, a simple variable is enough to store the function signatures. The time-redundant execution implementation differs more from the one presented in [4] and is thus briefly described below. The figures only show a simplified view of the advice code of the implementation.…”

Section: Aspectc++ Implementationmentioning

confidence: 99%

“…AspectC++ is an extension to C++ but since C is a subset of C++ it can also be used together with C programs. In an earlier study [4] we evaluated AspectC++ for fault tolerance purposes from a functional perspective. We also extended the language in order for it to be fully feasible.…”

Section: A Aspect-oriented Programmingmentioning

confidence: 99%

See 3 more Smart Citations

On Hardware Resource Consumption for Aspect-Oriented Implementation of Fault Tolerance

Alexandersson

2010

2010 European Dependable Computing Conference

Self Cite

View full text Add to dashboard Cite

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.

show abstract

Section: Aspectc++ Implementationmentioning

confidence: 97%

Section: Aspectc++ Implementationmentioning

confidence: 97%

Section: Aspectc++ Implementationmentioning

confidence: 99%

Section: A Aspect-oriented Programmingmentioning

confidence: 99%

See 2 more Smart Citations

On Hardware Resource Consumption for Aspect-Oriented Implementation of Fault Tolerance

Alexandersson

2010

2010 European Dependable Computing Conference

Self Cite

View full text Add to dashboard Cite

show abstract

“…Our technique can also be easily adopted by other programming systems such as OpenMP [29] and Cilk [30]. In [31][32][33], AOP was used to replicate objects for fault tolerance. In [34], AOP was used to introduce fault tolerance for transient faults, hardware permanent faults, and residual software faults in embedded systems applications.…”

Section: Related Workmentioning

confidence: 99%

Aspect-oriented development of cluster computing software

2011

View full text Add to dashboard Cite

In complex software systems, modularity and readability tend to be degraded owing to inseparable interactions between concerns that are distinct features in a program. Such interactions result in tangled code that is hard to develop and maintain. Aspect-Oriented Programming (AOP) is a powerful method for modularizing source code and for decoupling cross-cutting concerns. A decade of growing research on AOP has brought the paradigm into many exciting areas. However, pioneering work on AOP has not flourished enough to enrich the design of distributed systems using the refined AOP paradigm. This article investigates three case studies that cover time-honored issues such as fault-tolerant computing, network heterogeneity, and object replication in the cluster computing community using the AOP paradigm. The aspects that we define here are simple, intuitive, and reusable. Our intensive experiences show that (i) AOP can improve the modularity of cluster computing software by separating the source code into base and instrumented parts, and (ii) AOP helps developers to deploy additional features to legacy cluster computing soft-A preliminary version [1] of this paper was presented at IEEE Cluster 2007,

show abstract

Aspect-Oriented Implementation of Fault Tolerance: An Assessment of Overhead

Alexandersson

Karlsson

2010

Lecture Notes in Computer Science

View full text Add to dashboard Cite

Implementing Fault Tolerance Using Aspect Oriented Programming

Cited by 10 publications

References 9 publications

On Hardware Resource Consumption for Aspect-Oriented Implementation of Fault Tolerance

On Hardware Resource Consumption for Aspect-Oriented Implementation of Fault Tolerance

Aspect-oriented development of cluster computing software

Aspect-Oriented Implementation of Fault Tolerance: An Assessment of Overhead

Contact Info

Product

Resources

About