Advertisement

Development of Fault-Tolerant Software Systems Based on Architectural Abstractions

  • Patrick H. S. Brito
  • Rogério de Lemos
  • Cecília M. F. Rubira
Part of the Lecture Notes in Computer Science book series (LNCS, volume 5292)

Abstract

The incorporation of fault tolerance into systems normally increases their complexity, which consequently makes their analysis more difficult. This paper discusses how architectural abstractions can be effective in developing fault-tolerant software systems. Depending on the fault model and the resources available, different abstractions can be employed for representing issues that are related to fault tolerance, such as error detection, and error and fault handling. These architectural abstractions, and their internal views, can be instantiated into concrete components and connectors for designing fault-tolerant software architectures. Since structural and behavioural properties associated with these abstractions are formally specified, the process of verifying and validating software architectures can be automated. In this paper, we show how appropriate architectural abstractions and a recursive process can facilitate the architectural modelling and analysis of fault-tolerant software systems. The feasibility of the proposed approach is demonstrated in the context of a critical real-time application.

Keywords

Fault Tolerance Error Detection Software Architecture Exception Handling Internal View 
These keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Preview

Unable to display preview. Download preview PDF.

Unable to display preview. Download preview PDF.

References

  1. 1.
    Abrial, J.-R., et al.: The B-Method. In: Proc. of the 4th Int. Symp. of VDM Europe on Formal Sof. Devel., vol. 2, pp. 398–405 (1991)Google Scholar
  2. 2.
    Anderson, T., Lee, P.A.: Fault Tolerance: Principles and Practice, 1st edn. Prentice-Hall, Englewood Cliffs (1981)Google Scholar
  3. 3.
    Avizienis, A., et al.: Basic concepts and taxonomy of dependable and secure computing. IEEE Trans. on Dependable and Secure Computing 1(1), 11–33 (2004)CrossRefGoogle Scholar
  4. 4.
    Brito, P.H.S., et al.: Architecture-centric fault tolerance with exception handling. In: Bondavalli, A., Brasileiro, F., Rajsbaum, S. (eds.) LADC 2007. LNCS, vol. 4746, pp. 75–94. Springer, Heidelberg (2007)CrossRefGoogle Scholar
  5. 5.
    Brito, P.H.S., et al.: Verification and validation of a fault-tolerant architectural abstraction. In: Proc. of the Workshop on Architecting Dependable Systems, pp. 1–6 (2007)Google Scholar
  6. 6.
    Butler, M.J., Leuschel, M.: Combining CSP and B for specification and property verification. In: Fitzgerald, J.S., Hayes, I.J., Tarlecki, A. (eds.) FM 2005. LNCS, vol. 3582, pp. 221–236. Springer, Heidelberg (2005)Google Scholar
  7. 7.
    Castor Filho, F., et al.: An architectural-level exception-handling system for component-based applications. In: de Lemos, R., Weber, T.S., Camargo Jr., J.B. (eds.) LADC 2003. LNCS, vol. 2847, pp. 321–340. Springer, Heidelberg (2003)Google Scholar
  8. 8.
    da Silva Jr., M.C., et al.: A Java component model for evolving software systems. In: Proc. of the 18th IEEE Int. Conf. on Automated Soft. Eng., pp. 327–330 (2003)Google Scholar
  9. 9.
    de Castro Guerra, P.A., et al.: A fault-tolerant software architecture for component-based systems. In: de Lemos, R., Gacek, C., Romanovsky, A. (eds.) Architecting Dependable Systems. LNCS, vol. 2677, pp. 129–149. Springer, Heidelberg (2003)CrossRefGoogle Scholar
  10. 10.
    de Lemos, R.: Architectural Fault Tolerance Using Exception Handling. In: de Lemos, R., Gacek, C., Romanovsky, A. (eds.) Architecting Dependable Systems IV. LNCS, vol. 4615, pp. 142–162. Springer, Heidelberg (2007)CrossRefGoogle Scholar
  11. 11.
    Denford, M., et al.: Architectural abstraction as transformation of poset labelled graphs. Journal of Universal Computer Science 10(10), 1408–1428 (2004)Google Scholar
  12. 12.
    Fahmy, H., Holt, R.C.: Software architecture transformations. In: Proc. of the Int. Conf. on Software Maintenance, pp. 88–96 (2000)Google Scholar
  13. 13.
    Moriconi, M., Riemenschneider, R.: Introduction to sadl 1.0 a language for specifying software architecture hierarchies. TR SRI-CSL-97-01, SRI International (March 1997)Google Scholar
  14. 14.
    Oquendo, F.: π-ARL: an architecture refinement language for formally modelling the stepwise refinement of software architectures. SIGSOFT Softw. Eng. Notes 29(5), 1–20 (2004)Google Scholar
  15. 15.
    Randell, B.: Turing memorial lecture facing up to faults. Computer Journal 43(2), 95–106 (2000)CrossRefGoogle Scholar
  16. 16.
    Schlichting, R.D., Schneider, F.B.: Fail-Stop Processors: An Approach to Designing Fault-Tolerant Computing Systems. Computer Systems 1(3), 222–238 (1983)Google Scholar
  17. 17.
    Siau, K., Halpin, T.A. (eds.): Unified Modeling Language: Systems Analysis, Design and Development Issues. Idea Group (2001)Google Scholar
  18. 18.
    Sloman, M., Kramer, J.: Distributed systems and computer networks. Prentice Hall International, Englewood Cliffs (1987)Google Scholar
  19. 19.
    Taylor, R.N., et al.: A component- and message- based architectural style for GUI software. In: Proc. of the 17th Int. Conf. on Soft. Eng., pp. 295–304 (1995)Google Scholar
  20. 20.
    Thomas, D., Barry, B.M.: Model driven development: the case for domain oriented programming. In: Companion of the 18th Annual ACM SIGPLAN Conf. on Object-oriented Programming, Systems, Languages, and Applications, pp. 2–7 (2003)Google Scholar

Copyright information

© Springer-Verlag Berlin Heidelberg 2008

Authors and Affiliations

  • Patrick H. S. Brito
    • 1
  • Rogério de Lemos
    • 2
  • Cecília M. F. Rubira
    • 1
  1. 1.Institute of ComputingState University of Campinas (Unicamp) 
  2. 2.Computing LaboratoryUniversity of Kent 

Personalised recommendations