Writing programs to manage and mitigate faults is a complex and usually custom process. Are there approaches to help one easily create a correct and reliable program when running on unreliable hardware? This paper reports on the goals where fault tolerance can be supported more seamlessly by adopting aspect-oriented programming (AOP). AOP is applied on a low-cost virtual platform called software implemented hardware fault tolerance (SIHFT). Since SIHFT code is both declarative and separated from the program code, AOP becomes an attractive approach.

The authors describe how AOP has four parts: definitions (core concerns), aspects (cross-cutting concerns), pointcuts, and advice functions. These are used to both add annotations in code and also to join (or weave) existing compilation units with specific aspect code. AOP tools like AspectC++ are discussed as examples with supporting code fragments. By applying AOP to building fault-tolerant programs, those cross-cutting concerns that deal directly with faults can be compiled (or woven) into the resulting program easier. This paper also shows how automatic metric collection might be one of those concerns where using AOP adds fault coverage used when evaluating any performance penalties. For example, AOP can be used in large programs by injecting thousands of faults and exploring how “tolerant” the resulting program behaves.

While the authors show results on performance, they acknowledge that more experiments are needed. They also identify some downsides, such as how the code weaving can be at a coarser level than many would like, relieving some desired control over the generated code.