*** empty log message ***
authorChao Huang <chuang10@uiuc.edu>
Thu, 22 Mar 2007 20:27:21 +0000 (20:27 +0000)
committerChao Huang <chuang10@uiuc.edu>
Thu, 22 Mar 2007 20:27:21 +0000 (20:27 +0000)
doc/charisma/manual.tex

index c48429c44314dadaa478b06048b61e8b7ffc26b9..1a79004026b8d6baa275ce61686f2da9c0d6da5c 100644 (file)
@@ -352,10 +352,13 @@ explicitly call initialization code for each array object.
 \subsubsection{Producing and Consuming Functions}
 The C/C++ source code is nothing different than ordinary sequential source code,
 except for the producing/consuming part. For consumed parameters, a function
-treat them just like normal parameters passed in. For produced parameters, the
-sequential code uses the keyword \code{produce} to connect the orchestration
-parameter and the local variables whose value will be sent out. The format is as
-follows.
+treat them just like normal parameters passed in. To handle produced parameters, 
+the sequential code needs to do two special things. First, the function should 
+have extra parameter for output parameters. The parameter type is keyword \code{outport},
+and the parameter name is the same as appeared in the orchestration code. Second,
+in the body of the function, the keyword \code{produce} is used to connect the 
+orchestration parameter and the local variables whose value will be sent out, in 
+a format of a function call, as follows.
 
 \begin{alltt}
     produce(produced\_parameter, local\_variable[, size\_of\_array]);
@@ -377,7 +380,11 @@ type and dimension of ``double [512]'', the producing statement should connect
 it with a local variable of ``double [512]''.
 
 \begin{alltt}
-    produce(lb,localRB,512);
+    void JacobiWorker::produceBorders(outport lb, outport rb)\{
+      . . .
+      produce(lb,localLB,512);
+      produce(rb,localRB,512);
+    \}
 \end{alltt}
 
 Special cases of the produced/consumed parameters involve scatter/gather
@@ -424,6 +431,40 @@ In sequential code, the user can access the object's index by a keyword
 6D: thisIndex.x1, thisIndex.y1, thisIndex.z1, thisIndex.x2, thisIndex.y2, thisIndex.z2
 \end{alltt}
 
+\section{Building and Running a Charisma Program}
+There are two steps to build a Charisma program: generating Charm++ program 
+from orchestration code, and building the Charm++ program. 
+
+1) Charisma compiler, currently named \code{orchc}, is used to compile the
+orchestration code (.or file) and integrate sequential code to generate a
+Charm++ program. The resultant Charm++ program usually consists of the 
+following code files: Charm++ Interface file ([modulename].ci), header file 
+([modulename].h) and C++ source code file ([modulename].C). The command 
+for this step is as follows.
+
+\begin{alltt}
+    > orchc [modulename].or
+\end{alltt}
+
+2) Charm++ compiler, charmc, is used to parse the Charm++ Interface (.ci) file,
+compile C/C++ code, and link and build the executable. The typical commands are:
+\begin{alltt}
+    > charmc [modulename].ci
+    > charmc [modulename].C -c
+    > charmc [modulename].o -o pgm -language charm++
+\end{alltt}
+
+Running the Charisma program is the same as running a Charm++ program, using
+Charm++'s job launcher \code{charmrun}. (On some platforms like CSE's Turing 
+Cluster, use the customized job launcher \code{rjq} or \code{rj}.) 
+
+\begin{alltt}
+    > charmrun pgm +p4
+\end{alltt}
+
+Please refer to Charm++'s manual and tutorial for more details of building 
+and running a Charm++ program. 
+
 \section{Support for Library Module}
 \label{sec:module}