FT Languages Home Page
The University of Arizona, Computer Science Department
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.
- 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.
A second line of language work concerned the use of non-imperative
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.
Richard Schlichting, Professor
- Vic Thomas, PhD Student, currently at Honeywell
- David Bakken, PhD Student, currently at BBN
- M. Suzuki
- T. Katayama
This research was supported by the
National Science Foundation (NSF) and the
Office of Naval Research (ONR).
back to Cactus home page
Last updated March 2, 1998
Richard D. Schlichting