Charm++ manual intro: removed text about history of charm++
[charm.git] / doc / charm++ / intro.tex
1 \section{Introduction}
2
3 \charmpp\ is an explicitly parallel language based on \CC\ with a runtime
4 library for supporting parallel computation called the Charm kernel.  It
5 provides a clear separation between sequential and parallel objects.  The
6 execution model of \charmpp\ is message driven, thus helping one write programs
7 that are latency-tolerant.  \charmpp\ supports dynamic load balancing while
8 creating new work as well as periodically, based on object migration.  Several
9 dynamic load balancing strategies are provided.  \charmpp\ supports both
10 irregular as well as regular, data-parallel applications.  It is built on top of the
11 {\sc Converse} interoperable runtime system for parallel programming.
12
13 Currently the parallel platforms supported by \charmpp\ are the BlueGene/L,BlueGene/P, PSC
14 Lemieux, IBM SP, SGI Origin2000, Cray XT3/4, Cray X1, Cray T3E, a single workstation or a
15 network of workstations from Sun Microsystems (Solaris), IBM RS-6000 (AIX) SGI
16 (IRIX 5.3 or 6.4), HP (HP-UX), Intel x86 (Linux, Windows 98/2000/XP), Intel
17 IA64, Intel x86\_64, multicore x86 and x86\_64, and Apple Mac. The communication protocols and infrastructures supported
18 by \charmpp\ are UDP, TCP, Myrinet, Infiniband, Quadrics Elan, Shmem, MPI and
19 NCSA VMI.  \charmpp\ programs can run without changing the source on all these
20 platforms.  Please see the \charmpp{}/\converse{} Installation and
21 Usage \htmladdnormallink{Manual}{http://charm.cs.uiuc.edu/manuals/html/install/manual.html}
22 for details about installing, compiling and running \charmpp\ programs.
23
24 \subsection{Overview}
25
26 \charmpp\ is an object oriented parallel language. What sets \charmpp\ apart
27 from traditional programming models such as message passing and shared variable
28 programming is that the execution model of \charmpp\ is message-driven.
29 Therefore, computations in \charmpp\ are triggered based on arrival of
30 associated messages. These computations in turn can fire off more messages to
31 other (possibly remote) processors that trigger more computations on those
32 processors.
33
34 At the heart of any \charmpp\ program is a scheduler that repetitively chooses
35 a message from the available pool of messages, and executes the computations
36 associated with that message.
37
38 The programmer-visible entities in a \charmpp\ program are:
39
40 \begin{itemize}
41 \item Concurrent Objects : called {\em chares}\footnote{
42       Chare (pronounced {\bf ch\"ar}, \"a as in c{\bf a}rt) is Old 
43       English for chore.
44       }
45 \item Communication Objects : Messages
46 \item Readonly data
47 \end{itemize}
48
49 \charmpp\ starts a program by creating a single \index{chare} instance of each
50 {\em mainchare} on processor 0, and invokes constructor methods of these
51 chares.  Typically, these chares then creates a number of other \index{chare}
52 chares, possibly on other processors, which can simultaneously work to solve
53 the problem at hand.
54
55 Each \index{chare}chare contains a number of \index{entry method}{\em entry
56 methods}, which are methods that can be invoked from remote processors. The
57 \charmpp\ runtime system needs to be explicitly told about these methods, via
58 an {\em interface} in a separate file.  The syntax of this interface
59 specification file is described in the later sections.
60
61 \charmpp\ provides system calls to asynchronously create remote \index{chare}
62 chares and to asynchronously invoke entry methods on remote chares by sending
63 \index{message} messages to those chares. This asynchronous
64 \index{message}message passing is the basic interprocess communication
65 mechanism in \charmpp. However, \charmpp\ also permits wide variations on this
66 mechanism to make it easy for the programmer to write programs that adapt to
67 the dynamic runtime environment.  These possible variations include
68 prioritization (associating priorities with method invocations), conditional
69 \index{message packing}message packing and unpacking (for reducing messaging
70 overhead), \index{quiescence}quiescence detection (for detecting completion of
71 some phase of the program), and dynamic load balancing (during remote object
72 creation). In addition, several libraries are built on top of \charmpp\ that
73 can simplify otherwise arduous parallel programming tasks.
74
75 The following sections provide detailed information about various features of the
76 \charmpp\ programming system.\footnote{For a description of the underlying design
77 philosophy please refer to the following papers :\\
78     L. V. Kale and Sanjeev Krishnan,
79     {\em ``\charmpp : Parallel Programming with Message-Driven Objects''},
80     in ``Parallel Programming Using \CC'',
81     MIT Press, 1995. \\
82     L. V. Kale and Sanjeev Krishnan,
83     {\em ``\charmpp : A Portable Concurrent Object Oriented System
84     Based On \CC''},
85     Proceedings of the Conference on Object Oriented Programming,
86     Systems, Languages and Applications (OOPSLA), September 1993.
87 }.
88 \subsection{History}
89
90 The {\sc Charm} software was developed as a group effort of the Parallel
91 Programming Laboratory at the University of Illinois at Urbana-Champaign.
92 Researchers at the Parallel Programming Laboratory keep \charmpp\ updated for
93 the new machines, new programming paradigms, and for supporting and simplifying
94 development of emerging applications for parallel processing.  The earliest
95 prototype, Chare Kernel(1.0), was developed in the late eighties. It consisted
96 only of basic remote method invocation constructs available as a library.  The
97 second prototype, Chare Kernel(2.0), a complete re-write with major design
98 changes.  This included C language extensions to denote Chares, messages and
99 asynchronous remote method invocation.  {\sc Charm}(3.0) improved on this
100 syntax, and contained important features such as information sharing
101 abstractions, and chare groups (called Branch Office Chares).  {\sc Charm}(4.0)
102 included \charmpp\ and was released in fall 1993.  \charmpp\ in its initial
103 version consisted of syntactic changes to \CC\ and employed a special
104 translator that parsed the entire \CC\ code while translating the syntactic
105 extensions.  {\sc Charm}(4.5)  had a major change that resulted from a
106 significant shift in the research agenda of the Parallel Programming
107 Laboratory. The message-driven runtime system code of the \charmpp\ was
108 separated from the actual language implementation, resulting in an
109 interoperable parallel runtime system called {\sc
110 Converse}. The \charmpp\ runtime system was
111 retargetted on top of {\sc Converse}, and popular programming paradigms such as
112 MPI and PVM were also implemented on {\sc Converse}. This allowed
113 interoperability between these paradigms and \charmpp. This release also
114 eliminated the full-fledged \charmpp\ translator by replacing syntactic
115 extensions to \CC\ with \CC\ macros, and instead contained a small language and
116 a translator for describing the interfaces of \charmpp\ entities to the runtime
117 system.  This version of \charmpp, which, in earlier releases was known as {\em
118 Interface Translator \charmpp}, is the default version of \charmpp\ now, and
119 hence referred simply as {\bf \charmpp}.  In early 1999, the runtime system of
120 \charmpp\ was formally named the Charm Kernel, and was rewritten in \CC.
121 Several new features were added. The interface language underwent significant
122 changes, and the macros that replaced the syntactic extensions in original
123 \charmpp, were replaced by natural \CC\ constructs. Late 1999, and early
124 2000 reflected several additions to \charmpp{}, when a load balancing
125 framework and migratable objects were added to \charmpp{}.