
\documentstyle[palatino,11pt]{genadmin}
%\documentstyle[palatino,11pt]{csart}
\begin{document}
\project{DOMUS}
\collaborator{University of Southampton \\
              Department of Electronics \\
              and Computer Science.}
\classification{}
\title{Workplan}
\date{21st December 1992}
\signature{MS 21.12.92 ~/hpf/workplan.tex}

\maketitle

\pagebreak[2]
\section{Introduction}

High Performance Fortran is intended to be a standard Fortran dialect
geared towards exploitation of data parallelism and efficient
implementation on message-passing MIMD parallel computers.  The full
language will have a large semantics, which will not be conducive to
rapid uptake by users and vendors of parallel machines.  An official
`subset' which may be implemented more quickly is therefore envisaged,
but recently even this has grown such that it will not be available in
short order.

The University of Southampton has been working for some years on ADAPT
-- a message passing Fortran dialect based on Fortran 90.  This will 
now be developed along the lines of HPF, and by building on the 
existing work, an implementation will be available in 1993.  As the HPF
standards converge, the ADAPT language will be well placed to approach
HPF syntactically.

The output language produced by the ADAPT compiler will be Fortran 90
with calls to a run-time communications support library known as ADLIB.
This too will build on work already underway at Southampton, in this 
case an Array Communications Library (ACL).  ADLIB will provide support 
for inter-processor HPF constructs on a distributed memory,
message-passing MIMD machine.  The intention is that ADAPT and ADLIB
together will provide an implementation of an HPF subset in short order
given a suitable Fortran 90 compiler, such as the one produced by NAG.

\pagebreak[2]
\section{Technical Objectives}

The project will implement the two components (other than the Fortran 90
compiler) required for the HPF-like system, namely the ADAPT compiler
and the ADLIB run-time message passing library.

The ADAPT compiler will build on current work in message-passing Fortran
dialects.  The objective will be implementation of the translation scheme 
for a significant fraction of HPF programming constructs to ADLIB and
Fortran 90.

The ADLIB development will provide a layered message passing interface
for run-time support as required by ADAPT.  The lowest level of ADLIB
only will be machine specific, so that the ADAPT/ADLIB system can be 
ported easily between message passing machines for which Fortran 90 is
supported.

\pagebreak[2]
\section{Project Tasks.}

It is envisaged that the work will proceed in three distinct phases.

The first phase will produce a detailed specification of the ADAPT
translation scheme and ADLIB run-time support library.  During this
stage, the top level routines from ADLIB will be implemented for a
single processor, providing a working basis for ADAPT.

This will be followed by a parallel development stage, in which the
ADAPT translation scheme and the layered, multi-processor ADLIB will 
be implemented.  A prototype ADAPT will be produced about half
way through this development for restricted release, supported by the
uni-processor ADLIB.  Feedback from users of this will be used to
guide subsequent development.

The final stage will involve integration of the two components of the
system and production of documentation for users.

\subsection{Task 1.  Design and Specification.}

The ADAPT translation scheme will be specified, defining both the input
and output language for the compiler.  The input language will include
templates, block, cyclic and cyclic($m$) distribution, general array
expressions and assignments, and the \verb"FORALL" and \verb"WHERE"
constructs.  The parameterization of distribution will handle general 
regular sections of the above distributions.

The specification of the ADAPT input language and translation scheme
will provide a complete description of the prototype ADAPT compiler, as
well as describing the final ADAPT system.

The ADLIB interface will form part of the output specification.  The
functionality of the ADLIB routines will in some cases be specified by a
single processor implementation.  This will provide run-time support for
early versions of the ADAPT language.

Specification of the ADAPT translation scheme for both input and output
languages, at the prototype stage and for the beta-standard system.
\newline 3 man-months.

Specification of ADLIB routine functionality, including single processor
implementation.
\newline 3 man-months.

\subsection{Task 2.  ADAPT Development.}

The ADAPT translation scheme will be implemented in two stages.  The
first stage will lead to a prototype containing :

\begin{itemize}
\item HPF data mapping directives, templates, etc.
\item Expression and assignment involving constant and variable
sections and distributions, but not array functions.
\item Input and output.
\end{itemize}

Subsequently, the translation scheme will be extended to include :

\begin{itemize}
\item Interface blocks.
\item Array functions.
\item Intrinsic functions.
\item The \verb"FORALL" and \verb"WHERE"
\item Other features (to be determined).
\end{itemize}

Feedback from users of the prototype ADAPT will guide the selection of
features to be included at this stage.

Implementation of the prototype ADAPT system.
\newline 4 man-months.

Implementation of the beta-standard ADAPT system.
\newline 4 man-months.

\subsection{Task 3.  ADLIB Development.}

The ADLIB library will be layered, with the lowest level only being
dependent on any machine or operating system specific features.  The
lower levels will be based on Array Communications Language routines,
with only the top level being strictly an ADLIB layer.

The lowest level is the ACL-0 channel-level, incorporating message
sequencing and queueing, dynamic channel handling, and providing
isolation from the underlying platform for higher layers.
\newline 2 man-months.

Level ACL-1 will provide communication structures for ``grid-oriented''
processor networks, including process grid creation and collective 
communication of amorphous data.
\newline 2 man-months.

Level ACL-2 will handle array oriented collective communications.
\newline 2 man-months.

The ADLIB layer will support operations required by the ADAPT system,
such as data redistribution, distribution inquiry, intrinsic array 
functions, I/O and process management.
\newline 2 man-months.

\subsection{Task 4.  Integration.}

The final task will involve integrating ADAPT and ADLIB to create the
final, beta system, which will be released to users of the prototype.
\newline 1 man-month.

User documentation will then be produced, with reference to reports 
from these users.
\newline 1 man-month.

\pagebreak[2]
\section{Resources.}

\subsection{Manpower.}

The equivalent of two research assistants, full time.

\subsection{Equipment and Software.}

Unix work-stations will be used to access parallel resources as required,
including the work-station network itself.

\pagebreak[2]
\section{Duration.}

One year from 1st January 1993. The progression and inter-dependence of
tasks are shown in Figure 1.

\pagebreak[2]
\section{Deliverables.}

\subsection{Task 1.}

{\it Deliverable 1.1} :
Specification of the ADLIB level procedure calls, including
identification of those needed to support the prototype ADAPT.
\newline End month 2.

{\it Deliverable 1.2} :
Implementation of prototype ADLIB for a single processor system.
\newline End month 3.

{\it Deliverable 1.3} :
Specification of the ADAPT translation scheme, incorporating a
specification of the half-way prototype.
\newline End month 3.

\subsection{Task 2.}

{\it Deliverable 2.1} :
Implementation of the prototype ADAPT translation scheme.
\newline End month 7.

{\it Deliverable 2.2} :
Implementation of the beta standard ADAPT.
\newline End month 11.

\subsection{Task 3.}

{\it Deliverable 3.1} :
Multi-processor implementation of the channel-level ACL-0 library.
\newline End month 5.

{\it Deliverable 3.2} :
Multi-processor implementation of the processor-level ACL-1 library.
\newline End month 7.

{\it Deliverable 3.3} :
Multi-processor implementation of the array-level ACL-2 library.
\newline End month 9.

{\it Deliverable 3.4} :
Multi-processor implementation of the ADLIB library.
\newline End month 11.

\subsection{Task 4.}

{\it Deliverable 4.1} :
User documentation for beta release of ADAPT/ADLIB subset of HPF.
\newline End month 12.

\begin{figure}[t]
\centerline{\psfig{figure=wkplan.fps,width=6in}}
\end{figure}

\clearpage
\mbox{}
\addtocounter{page}{-1}
\label{lastpage}

\end{document}

