The Aurora Distributed Shared Data System
Introduction |
Aurora is
a distributed shared data (DSD) system based
on a standard C++ class library and run-time system.
As with related systems, it provides a shared data programming
abstraction on distributed memory hardware.
The system does not contain any language extensions
and it does not require special hardware support.
Instead, Aurora exploits language mechanisms for
creating abstract data types.
Aurora has a novel interface,
called scoped behaviour,
for specifying various data sharing optimizations.
Scoped behaviour provides per-context and per-object
optimization flexibility for a variety of data sharing patterns and idioms.
The abstracts and papers listed below provide further details
on the design, implementation, and performance of Aurora.
This work started as part of the
Parallelism on Workstations
(POW) project at the
University of Toronto.
I am continuing this work at an
Assistant Professor
in the
Department of Computing Science,
of the
University of Alberta.
|
Ph.D. Thesis |
As of August 2000, the most comprehensive description
of Aurora and how to implement scoped behaviour is my
Ph.D. thesis.
That will likely change as I continue working on the Aurora system.
The JPDC 2001 paper (see below) on Integrating Bulk-Data Transfer
discusses many of the implementation details from my thesis.
|
Original
Overview
Paper |
Abstract:
We introduce the all-software, standard C++-based Aurora
distributed shared data system.
As with related systems, it provides a shared data abstraction on
distributed memory hardware.
An innovation in Aurora is the use of scoped behaviour
for per-context data sharing optimizations
(i.e., portion of source code, such as a loop or phase).
With scoped behaviour, a
new language scope (e.g., nested braces)
can be used to optimize the data sharing behaviour
of the selected source code.
Different scopes and different shared data can be optimized
in different ways.
Thus, scoped
behaviour provides a novel level of
flexibility to incrementally tune the parallel
performance of an application.
|
Book Chapter
(Overview) |
|
How to Implement
Scoped Behaviour |
The conference paper (below) has fewer performance results,
but more implementation details, than this journal paper.
Such is academic publishing sometimes.
As of August 2000, the most comprehensive description
of Aurora and how to implement scoped behaviour is my
Ph.D. thesis (see above).
That will likely change as I continue working on the Aurora system.
|
Abstract:
Sometimes, it is desirable
to alter or optimize
the behaviour of an object
according to the needs of a specific
portion of the source code (i.e., context),
such as a particular loop or phase.
One technique to support
this form of optimization flexibility
is a novel approach called scoped behaviour .
Scoped behaviour allows the programmer to
incrementally tune applications on a
per-object and per-context basis within standard C++.
We explore the use of scoped behaviour
in the implementation of the Aurora distributed shared data (DSD) system.
In Aurora, the programmer uses scoped behaviour as the interface to
various data sharing optimizations.
We detail how a class library implements the basic data sharing functionality
and how scoped behaviour coordinates the compile-time and run-time
interaction between classes to implement the optimizations.
We also explore how the library can be expanded with
new classes and new optimization behaviours.
The good performance of Aurora
suggests that using scoped behaviour and a class library
is a viable approach for supporting this form of
optimization flexibility.
|
Integrating
Bulk-Data Transfer |
Abstract:
The Aurora distributed shared data system implements
a shared-data abstraction on distributed-memory platforms,
such as clusters,
using abstract data types.
Aurora programs are written in C++ and instantiate
shared-data objects whose data-sharing behaviour
can be optimized using a novel technique called scoped behaviour.
Each object and each phase of the computation (i.e., use-context)
can be independently optimized
with per-object and per-context flexibility.
Within the scoped behaviour framework,
optimizations such as bulk-data transfer
can be implemented and made available to the application programmer.
Scoped behaviour carries semantic information regarding
the specific data-sharing pattern through various layers of software.
We describe how the optimizations are integrated from the
uppermost application-programmer layers down to the lowest
UDP-based layers of the Aurora system.
A bulk-data transfer network protocol bypasses
some bottlenecks associated with TCP/IP and achieves higher performance
on an ATM network
than either TreadMarks (distributed shared memory) or MPICH (message passing)
for matrix multiplication and parallel sorting.
|
Related Links
on the Web |
|
|