|
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.
|
back to Cactus home page
