FT Languages Home Page

The University of Arizona, Computer Science Department
Research Projects


The fault-tolerant languages projects aim at enhanced programming language support for distributed programs that have fault-tolerance requirements. Most current high-level programming languages lack adequate support for constructing fault-tolerant distributed programs, especially at the systems level. The three specific projects, FT-SR, FT-Linda, and FTAG, were aimed at improving this situation.

Overview
  • FT-SR: is a concurrent programming language that supports fault tolerance. FT-SR is based on the SR concurrent programming language. FT-SR is unique in that it has been designed to support equally well any of the programming paradigms that have been developed for fault-tolerant distributed systems, including the object/action model, the restartable action paradigm, and the replicated state machine approach. To do this, the language is designed to support the implementation of systems modeled as collections of fail-stop atomic objects. Such objects execute operations as atomic actions except when a failure or series of failures cause underlying implementation assumptions to be violated; in this case, notification is provided. Specific language features include provisions for encapsulation based on SR resources, resource replication, recovery protocols, synchronous failure notification when performing interprocess communication, and a mechanism for asynchronous failure notification. An x-kernel based prototype running on a network of Sun 3 workstations was implemented and tested.

  • FT-Linda: The second language-oriented effort investigated the use of more non-traditional languages and notations for performing fault-tolerant distributed programming. One part of our work in this area concentrated on extending the well-known Linda coordination language to facilitate programming of fault-tolerant parallel applications. Key features include:

    • A guarded atomic statement to allow multiple tuple space operations to be executed atomically.

    • Provisions for multiple tuple spaces, including shared stable tuple spaces that are resilient to failures.

    • Move and copy primitives to transfer tuples between tuple spaces.

    • The system design is based on using ordered atomic multicast in the runtime system, a strategy that allows efficient implementation of stable tuple spaces as replicated state machines.

  • FTAG: A second line of language work concerned the use of non-imperative programming models for fault tolerance, in particular, development of a functional and attribute based model called FTAG. This model offers several advantages when compared with imperative languages, including a declarative style, separation of semantic and syntactic definitions, and the simplicity of a functional foundation. While important for any type of programming, these advantages are especially pronounced for writing fault-tolerant programs that involve the use of state rollback.

Project Members
  • Richard Schlichting, Professor

  • Vic Thomas, PhD Student, currently at Honeywell Research Center

  • David Bakken, PhD Student, currently at BBN

  • M. Suzuki

  • T. Katayama


Resources

This research was supported by the National Science Foundation (NSF) and the Office of Naval Research (ONR).


back to Cactus home page

------------------------------------------------------------------------
http://www.cs.arizona.edu/ftol/languages/index.html
Last updated March 2, 1998
Richard D. Schlichting (rick@cs.arizona.edu)