NetNews Usenet Archive 1993 #1/NN_1993_1.iso/spool/comp/parallel/2857

Text File | 1993-01-05 | 7.8 KB | 187 lines

Newsgroups: comp.parallel
Path: sparky!uunet!gatech!hubcap!fpst
From: [e-mail]
Subject: CHARM : more information
Message-ID: <[e-mail]>
Apparently-To: [e-mail]
Sender: [e-mail]
Organization: Dept. of Computer Sci - University of Illinois
Date: Mon, 4 Jan 1993 22:23:28 GMT
Approved: [e-mail]
Lines: 174


Thanks for the response to our announcement of the CHARM (v3.2)
parallel programming system. This posting includes:

1. A correction to the previous note:
    The name of the directory containing CHARM at a.cs.uiuc.edu is:
    pub/CHARM (and not pub/charm as posted earlier.)

2. Information about a new mailing list for CHARM related discussions,
   and bug reports.

3. As some of you requested information about what CHARM is, I am
   including a brief description of some its features.

--------------------------------------------------------------

A mailing list for CHARM related discussions has been created.
To become members of this list, send email to [e-mail],
containing the following line in the body of the message:
subscribe charm <Full-name>

To send mail to everyone on the list: send it to: [e-mail].

Bug reports should be sent to [e-mail].

--------------------------------------------------------------
        Brief description of CHARM features:

CHARM is a machine independent parallel programming system. Programs
written using this system will run unchanged on MIMD machines with or
without a shared memory. It provides high-level mechanisms and
strategies to facilitate the task of developing even highly complex
parallel applications.

The programs are written in C with a few syntactic extensions.
It is possible to interface to other languages such as FORTRAN using
the foreign language interface that C provides.

Platforms: The system currently runs on Intel's iPSC/860, iPSC/2,
NCUBE, Encore Multimax, Sequent Symmetry, ALLIANT FX/8,
single-processor UNIX machines, and networks of workstations.
It is being ported to a CM-5, Parsytec GC-el, and Alliant FX/2800.
We plan to port it to other parallel machines as they become available.

The design of the system is based on the following tenets:

1. Efficient Portability:
   Locality of data is the cost measure that applies across all
   MIMD machines. The system design induces better data locality. This
   is how it can support machine independence without losing efficiency.

2. Latency Tolerance:
   Latency of communication - the idea that remote data will take
   longer to access - is a significant issue common across most
   MIMD platforms.  Message-driven execution, supported in CHARM,
   is a very useful mechanism for tolerating or hiding this latency.
   In message driven execution (which is distinct from just
   message-passing), a processor is allocated to a process only
   when a message for the process is received. This means when a
   process blocks, waiting for a message, another process may execute
   on the processor. It also means that a single process may block for
   any number of distinct messages, and will be awakened when any
   of these messages arrive. Thus, it forms an effective way of
   scheduling a processor in the presence of potentially large
   latencies.

3. Dynamic Load Balancing:
   Dynamic creation of work is necessary in many applications
   programs. CHARM supports this by providing dynamic (as well as
   static) load balancing strategies.

4. Specific Information Sharing Modes:
   A major activity in a parallel computation is creation and sharing
   of information. Information is shared in many specific modes.  The
   system provides six information sharing modes, each of which may be
   implemented differently and efficiently on different machines.

5. Reuse and Modularity:
   It should be possible to develop parallel software by reusing
   existing parallel software. CHARM supports this with a
   well-developed ``module'' construct, and associated mechanisms.
   These mechanisms allow for compositionality of modules without
   sacrificing the latency-tolerance. With them, two modules, each
   spread over hundreds of processors, may exchange data in a
   distributed fashion.

The Programming Model:

Programs consist of potentially small-grained processes
(called chares), and a special type of replicated processes.
These processes interact with each other via messages and any of
the other information-sharing abstractions. There may be thousands
of small-grained processes on each processor, or just a few, depending
on the application.  The ``replicated processes'' can also be used
for implementing novel information sharing abstractions, distributed
data structures, and intermodule interfaces.  The system can be
considered a concurrent object-oriented system with a clear separation
between sequential and parallel objects.

Libraries:

The modularity-related features make the system very attractive for
building library modules that are highly reusable because they can
be used in a variety of data-distributions.  We have just begun the
process of building such libraries, and have a small collection of
library modules. However, we expect such libraries, contributed by
us and other users, to be one of the most significant aspects of the
system.

Regular and Irregular Computations:

For regular computations, the system is useful because it provides
portability, static load balancing, and latency tolerance via message
driven execution, and facilitates construction and flexible reuse of
libraries.  The system is unique for the extensive support it provides
for highly irregular computations. This includes management of many
small-grained processes, support for prioritization, dynamic load
balancing strategies, handling of dynamic data-structures such as
lists and graphs, etc.  The specific information sharing modes are
especially useful for such computations.

The system has been used for many applications. For example,
many VLSI-CAD applications (including test-pattern generation, circuit
extraction, etc.) were implemented by B. Ramkumar and P. Banerjee
using CHARM. An implementation of Actors language was carried out by
Chris Houck under the direction of Gul Agha. In addition, several CFD
algorithms, AI algorithms, a molecular dynamics program, etc. have been
written using CHARM.

Distribution:

The system is available (for research use and evaluation) by anonymous
ftp, from a.cs.uiuc.edu, under the directory pub/CK. The files there
include a manual, installation scripts, a README file that explains
how to install the system on your machine, and the requisite
source/object files.

Associated Tools:

1. Dagger: allows specification of dependences between messages and
   sub-computations within a single process, provides a pictorial
   view of this dependence graph, and simplifies management of
   message-driven execution.

2. Projections:  is a performance visualization and feedback tool. The
   system has a much more refined understanding of user computation
   than is possible in traditional tools. Thus it can provide much
   specific feedback. Future versions will be able to provide
   recommendations and suggestions for improving performance.

Future Plans:

Some of the ongoing projects based on CHARM include---

1. DP-Charm: A Data Parallel Language, providing a subset of HPF
   features.

2. Other base languages: The basic ideas and techniques used in CHARM
   are independent of the base language used. We plan to incorporate
   them in other languages including FORTRAN, C++, and Scheme.

3. Debugging Tools: Based on the specificity of information available
   to the runtime system, we plan to develop both trace-based and
   run-time debugging tools for CHARM.

Contact:
L.V. Kale [e-mail]
Department of Computer Science, [phone]
University of Illinois at Urbana Champaign
1304 W. Springfield Ave., Urbana, IL-61801