Coyote Overview
Coyote
An Approach to Constructing Configurable Fault-Tolerant
Distributed Services
Department of Computer Science
The University of Arizona
Complex applications built on a distributed architecture can be
simplified if the underlying software provides suitably tailored
communication-oriented abstractions. For example, ordered atomic
multicast provides atomic and consistently ordered message delivery
to a group of processes, which can be useful for writing real-time and
fault-tolerant distributed applications. Other abstractions of this type
include group RPC, membership, and distributed transactions. Such
abstractions logically form a distribution support layer - that
is, a layer that provides execution guarantees regarding the
distributed state of the application - that occupies a place in the system
hierarchy between the application and traditional operating
system functionality. From a networking perspective, they can be viewed
as application-oriented network protocols or distributed services that
are implemented at a high level in the protocol stack.
Coyote is a system that supports the construction of highly modular and
configurable versions of complex high-level protocols. Coyote extends
the notion of protocol objects supported by systems such as ADAPTIVE,
Horus, and the x-kernel to finer-grain modules called micro-protocols
that implement individual properties of the target service as separate
modules. For example, with atomic multicast, one micro-protocol
might implement the consistent ordering requirements, while another
might implement reliable transmission.
Micro-protocols can also be used to implement different semantic variants
of the same property.
For example, there may be multiple micro-protocols implementing different
message-ordering or retransmission policies.
A service is then configured from a suite of micro-protocols
representing a range of possible semantic choices based on the particular
execution guarantees needed for the given application.
Micro-protocols are structured using events and event handlers,
which enhance configurability by minimizing explicit references between
modules.
Our approach provides a number of advantages over a monolithic
approach to constructing similar services or systems that support only
coarse-grain hierarchical composition.
These include:
- Configurability. With fine-grain semantic-based
configurability, customized services can be constructed that
provide execution guarantees that are targeted to the specific
requirements of the application.
- Efficiency. With a customized service, the application
can avoid execution overhead that often results from inclusion of
unnecessary properties in monolithic services, as well as
choose the most efficient alternative given the current execution
environment.
- Reusability. The same collection of micro-protocols can be
used to construct multiple related services for different applications
rather than having to implement entirely new services from scratch.
- Extensibility. New execution properties can be added
as needed by writing additional micro-protocols and including them in
an existing micro-protocol suite.
- Expressibility. The approach provides a new,
more general model for structuring protocol objects that
allows micro-protocols implementing a given service to communicate
using events or shared data as appropriate.
The need for a new approach has been reinforced by experience with
existing systems. For example, using the x-kernel to construct Consul,
a protocol suite implementing atomic multicast, highlighted deficiencies
in several areas, including support for complex interactions among protocol
objects, limited facilities for data sharing, and an orientation towards
hierarchical protocol composition at the expense of more flexible combinations.
The developers of xAMP, a real-time atomic multicast protocol, report a
similar experience. The lack of a sufficiently rich protocol object interface
has also been cited as one of the motivations for developing Horus, a successor
to the Isis system.
Two prototype versions of Coyote have been constructed, including one
that augments the x-kernel's standard hierarchical object
composition model with the ability to internally structure
x-kernel protocol objects using micro-protocols.
The result is a two-level model in which selected micro-protocols
are first combined with a standard runtime system or framework to
form a composite protocol that implements the desired service.
This composite protocol, whose external interface is indistinguishable
from a standard x-kernel protocol, is then composed with
other x-kernel protocols in the normal hierarchical way to realize
the overall functionality required.
Internally, the framework implements an event-driven
execution paradigm,
in which event handlers within micro-protocols are executed
whenever events for which they are registered---for example, message
arrival or a timeout---occur.
Thus, when compared with standard x-kernel protocol objects,
micro-protocols are typically finer-grain objects that interact more
closely and do so using mechanisms
provided by the framework rather than the x-kernel Uniform
Protocol Interface (UPI).
The second prototype is written in C++.
It demonstrates the generality of the approach and serves as
another platform for prototyping composite protocols.
A number of configurable services have been developed using this
paradigm, including group RPC, membership, and protocols for mobile
computing.
back to Coyote home page
http://www.cs.arizona.edu/coyote/overview.html
Last updated March 2, 1998
Matti Hiltunen
(hiltunen@cs.arizona.edu)