Return to home page


The Aurora Distributed Shared Data System


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

Paul Lu. Scoped Behaviour for Optimized Distributed Data Sharing , Ph.D. thesis, Department of Computer Science, University of Toronto, Toronto, Ontario, Canada, 2000.

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.


Paul Lu. Aurora: Scoped Behaviour for Per-Context Optimized Distributed Data Sharing , 11th International Parallel Processing Symposium (IPPS), Geneva, Switzerland, April 1-5, 1997, pp. 467-473. Compressed postscript (46 kbytes). BibTeX entry here.

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

Paul Lu. Using Scoped Behaviour to Optimize Data Sharing Idioms , in High Performance Cluster Computing: Programming and Applications, Volume 2, 1/e , Rajkumar Buyya (editor), Prentice Hall PTR, pp. 113-130, 1999. Draft. Compressed postscript (294 kbytes). BibTeX entry here. This chapter is an expanded version of the IPPS 1997 conference paper.

How to Implement
Scoped Behaviour

Paul Lu. Implementing Scoped Behaviour for Flexible Distributed Data Sharing , IEEE Concurrency, vol 8, no. 3, pp. 63-73, July-September 2000. Gzipped postscript (57 kbytes) BibTeX entry here. Also available, with password, from IEEE Digital library in Acrobat PDF. Table of contents of Vol. 8, No. 3 is here. This paper is an expanded version of the COOTS 1997 conference paper.

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.

Paul Lu. Implementing Optimized Distributed Data Sharing Using Scoped Behaviour and a Class Library , 3rd Conference on Object-Oriented Technologies and Systems (COOTS), Portland, Oregon, U.S.A., June 16-19, 1997, pp. 145-158. Compressed postscript (65 kbytes). Minor corrections made July 3, 1997. Also available in HTML here. And, BibTeX entry here.

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.

Bulk-Data Transfer

Paul Lu. Integrating Bulk-Data Transfer into the Aurora Distributed Shared Data System , Journal of Parallel and Distributed Computing, Vol. 61, No. 11, pp. 1609-1632, November 2001. Adobe Acrobat(123 kbytes) BibTeX entry here. Typeset version available, with password, from Idea Library Acrobat PDF. Table of contents of JPDC Vol. 61, No. 11 is here.

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

Return to home page
$Id: aurora.html,v 1.29 2007/06/01 00:19:06 paullu Exp paullu $