Newsgroups: comp.parallel
From: R.Standish@unsw.edu.au (Russell Standish)
Subject: parallel c++ class - summary of responses
Date: Wed, 25 Aug 1993 14:20:49 GMT

I have had a good response to my question on C++ classes for
implementing data parallel variables. A number of different approaches
(and interpretations) were taken of my question. 

My application was to be able to write code on my workstation (either
my Linux PC at home, or the Sun workstation at work) that could also
run on the CM5 using the parallel architecture. I am also concerned
whether my code will be usable on any future machines. The target
languages on the CM5 are CMFortran and C*. As CMFortran is a subset of
Fortran 90, one might expect that future portability of this language
to be ensured, however Fortran90 compilers are not freely available
yet (there is one available from NAG, but I would prefer to wait for
the moment).  C* is a one of a kind language, which I expect will
limit your software to the Connection Machine. At the time of writing,
Thinking Machines have released a Fortran77 to CMFortran translator,
which works like a vectorizing compiler. This actually does solve the
portability problem, as f2c is a freely available F77 to C translator.

I am now experimenting with C++, which at present I am convinced is
nearly ideal for scientific programming purposes. I have long wished
for operator overloading so that complicated mathematical expressions
involving arbitrary data types could be written as they appear on the
page. C++ offers this, so does Fortran90. However C++ is available
now, whereas true Fortran 90 is still in the future. I also think
that C++ is neater and leaner than Fortran90, which is a minor
advantage. Anyway, it made me think that I could define a parallel
data type (or at least data types corresponding to the usual scalar
data types ints, floats, doubles etc.) The properties of this data
type would be things like geometry (how the data is laid out on the
machine), and pointers which locate the data in distributed memory.
All this detail could be abstracted away, along with the communication
primitives, by a class which defines array operations (aka Fortran
90). So, this is what prompted my question.

I had the following responses to my question:

Parallel Programming Classes for C++:
  ParLib++, developed by David Greco at David.Greco@crs4.it
  P++, developed by Dan Quinlan at danq@lemond.colorado.edu
  "C* in C++" developed by Terry Bossomaier at terry@arp.anu.edu.au

N.B., I haven't had a response from the authors of P++ or the C* class
to be able to properly evaluate their functionality.

New Object Oriented Languages for Data Parallel Programming:
  Mentat, available by anonymous ftp from server.cs.virginia.edu
  pC++, available soon from gannon@cs.indiana.edu

Mentat is available only for Suns, Silicon Graphics, IBM RS6000s and
Intel IPSC/860s.
pC++ is a preprocessor for C++ that implements a data parallel
extension. Machines currently supported are CM5, paragon, KSR-1,
sequent, BBNTC2000 (and soon ibm sp1, and cray t3d), as well as in
uniprocessor mode on most workstations.

C++ classes for message passing environments:
  NetClasses++, available from Qualix Group, info@qualix.com
  DoPVM - a class built on PVM from Skip Hartley, skip@mathcs.emory.edu

I personally think that message passing environments require more
evolution before there is any kind consensus, let alone standard.
Therefore C++ classes may be premature in this case.

At this stage, I will look at ParLib++, and also at pC++ when it is
available. I don't know whether parallel extensions are really
required (thus mandating a preprocessor aka pC++) or whether it can
all be done satisfactorily within "standard" C++.

		Thank you for all your interest and advice.
--------------------------------------------------------
Dr. Russell Standish            	Distributed Systems Manager
Classic Inn,
Jl Kis Mangunsarkoro, 28	   	Phone +62 21 390 0861
Menteng, Jakarta Pusat			Fax   +62 21 331 164
Indonesia				R.Standish@unsw.edu.au