Made converse manual use pplmanual style.
authorMilind Bhandarkar <milind@cs.uiuc.edu>
Mon, 11 Dec 2000 22:51:46 +0000 (22:51 +0000)
committerMilind Bhandarkar <milind@cs.uiuc.edu>
Mon, 11 Dec 2000 22:51:46 +0000 (22:51 +0000)
doc/converse/ccs.tex
doc/converse/cmi.tex
doc/converse/conditions.tex
doc/converse/cpvmacros.tex
doc/converse/manual.tex
doc/converse/simulator.tex
doc/converse/threads.tex
doc/converse/usermain.tex
doc/pplmanual.tex

index 314562a8727f89751cd627578d91fefd9cea5311..492978e4143de3e6b6b50956a5c978bb04559503 100644 (file)
@@ -1,16 +1,16 @@
-\chapter{Converse Client-Server Interface}
+\chapter{\converse{} Client-Server Interface}
 
-This note attempts at explaining the design of CCS module of Converse. This
+This note attempts at explaining the design of CCS module of \converse{}. This
 module is responsible for enabling parallel servers to be written using
-Converse. Currently, this module will be implemented only on network of
+\converse{}. Currently, this module will be implemented only on network of
 workstations. Other parallel architectures will follow.
 
 The CCS module is split into two parts. One part consists of functions that can
-be used in Converse programs which act as servers. The other part consists of
+be used in \converse{} programs which act as servers. The other part consists of
 functions that can be used with clients that try to connect to servers written
 using CCS. The following sections describe both these parts. {\tt conv-host} is
 sometimes also referred to as {\tt server-host} in order to distinguish it from
-the individual converse processes which are sometimes referred to as {\tt
+the individual \converse{} processes which are sometimes referred to as {\tt
 server-processes}. Together, the {\tt server-host} and the {\tt
 server-processes} constitute a server. In general, the client does not need to
 know the difference.
@@ -18,7 +18,7 @@ know the difference.
 
 \section{CCS: Server-Side}
 
-On the network of workstations, any converse program is started using
+On the network of workstations, any \converse{} program is started using
 \begin{quotation} conv-host pgmname +pN conv-host-opts pgm-opts \end{quotation}
 In addition to the original options, now conv-host accepts one more option:
 {\tt ++server}.  Currently this option makes conv-host print out its own
@@ -52,7 +52,7 @@ normal remote invocation too. ({\tt CcsRegisterHandler} internally calls
 \linebreak {\tt CmiRegisterHandlerLocal}.)
 
 Handler functions responsible for remote requests have the same syntax and
-semantics as the normal Converse handlers. However, in the handler function
+semantics as the normal \converse{} handlers. However, in the handler function
 invoked by a remote request, {\tt CcsIsRemoteRequest() } returns {\tt  1}.
 Also, in that case, {\tt  CcsCallerId() } returns meaningful values for IP
 address and Port of the caller. No message format conversion is actually done
index e46285a50c5d58e4ecd508d7a9839cf6eeb50b5a..318b8ff763dc1adfe7f6cb1eff13f8fca841808f 100644 (file)
@@ -1,14 +1,14 @@
 \chapter{Machine Interface and Scheduler}
 
-This chapter describes two of Converse's modules: the CMI, and the
+This chapter describes two of \converse{}'s modules: the CMI, and the
 CSD.  Together, they serve to transmit messages and schedule the
 delivery of messages. First, we describe the machine model assumed by
-Converse.
+\converse{}.
 
 \section{Machine Model}
 \label{model}
 
-Converse treats the parallel machine as a collection of nodes, where
+\converse{} treats the parallel machine as a collection of nodes, where
 each node is comprised of a number of processors that share memory 
 In some cases, the number of processors per node may be exactly one  
 (e.g. Distributed memory multicomputers such as IBM SP.)  
@@ -32,7 +32,7 @@ number}, which specifies which handler function is to be executed when
 the message arrives.  Before you can send a message, you have to
 define the handler numbers.
 
-Converse maintains a table mapping handler numbers to function
+\converse{} maintains a table mapping handler numbers to function
 pointers.  Each processor has its own copy of the mapping.  There is a
 caution associated with this approach: it is the user's responsibility
 to ensure that all processors have identical mappings.  This is easy
@@ -43,12 +43,12 @@ The following functions are provided to define the handler numbers:
 
 \function{typedef void (*CmiHandler)(void *)}
 \index{CmiHandler}
-\desc{Functions that handle Converse messages must be of this type.}
+\desc{Functions that handle \converse{} messages must be of this type.}
 
 \function{int CmiRegisterHandler(CmiHandler h)}
 \index{CmiRegisterHandler}
 \desc{This represents the standard technique for associating numbers
-with functions.  To use this technique, the Converse user registers
+with functions.  To use this technique, the \converse{} user registers
 each of his functions, one by one, using CmiRegisterHandler.  One must
 register exactly the same functions in exactly the same order on all
 processors.  The system assigns monotonically increasing numbers to
@@ -58,9 +58,9 @@ chosen for the function being registered.}
 
 \function {int CmiRegisterHandlerGlobal(CmiHandler h)}
 \index{CmiRegisterHandlerLocal}
-\desc{This represents a second registration technique.   The Converse
+\desc{This represents a second registration technique.   The \converse{}
 user registers his functions on processor zero, using
-CmiRegisterHandlerGlobal.  The Converse user is then responsible for
+CmiRegisterHandlerGlobal.  The \converse{} user is then responsible for
 broadcasting those handler numbers to other processors, and installing
 them using CmiNumberHandler below.  The user should take care not to
 invoke those handlers until they are fully installed.}
@@ -97,17 +97,17 @@ occur as a result of this combination.
 A message handler function is just a C function that accepts a void
 pointer (to a message buffer) as an argument, and returns nothing.  The
 handler may use the message buffer until it returns, at which time
-Converse will automatically free the message buffer.  This behavior
+\converse{} will automatically free the message buffer.  This behavior
 can be overrided using CmiGrabBuffer:
 
 \function{void CmiGrabBuffer(void **pbuf)}
 \index{CmiGrabBuffer}
 \desc{A handler function receives a pointer to a message buffer
 as an argument.  Normally, it is supposed to copy the data out of the
-message buffer before it returns, at which time Converse automatically
+message buffer before it returns, at which time \converse{} automatically
 frees the message buffer.  However, a handler function may use
 CmiGrabBuffer to claim ownership of the message buffer (and therefore
-prevent Converse from freeing it).  Assuming, for example, that the
+prevent \converse{} from freeing it).  Assuming, for example, that the
 handler function called its argument {\tt msg}, it would call {\tt
 CmiGrabBuffer(\&msg)}.  Afterward, {\tt msg} contains a pointer to the
 message, or a copy of it.  From that point forward, it is the user's
@@ -117,11 +117,11 @@ responsibility to free the message using \param{CmiFree.}}
 \index{CmireleaseBuffer}
 \desc{A handler function receives a pointer to a message buffer
 as an argument.  Normally, it is supposed to copy the data out of the
-message buffer before it returns, at which time Converse automatically
+message buffer before it returns, at which time \converse{} automatically
 frees the message buffer or may reuse it for further communication.  
 However, a handler function may use
 CmiReleaseBuffer to give up ownership of the message buffer in the
-middle of handler execution (and therefore allowing Converse to reuse it).}
+middle of handler execution (and therefore allowing \converse{} to reuse it).}
 
 \section{Building Messages}
 
@@ -129,7 +129,7 @@ To send a message, one first creates a buffer to hold the message.
 The buffer must be large enough to hold the header and the data.
 The buffer can be in any kind of memory: it could be a local variable,
 it could be a global, it could be allocated with {\tt malloc}, and
-finally, it could be allocated with {\tt CmiAlloc}.  The Converse user
+finally, it could be allocated with {\tt CmiAlloc}.  The \converse{} user
 fills the buffer with the message data.  One puts a handler number
 in the message, thereby specifying which handler function the message
 should trigger when it arrives.  Finally, one uses a message-transmission
@@ -315,13 +315,13 @@ The {\bf msgComps[]} array is the array of the messages.
 
 The indexing in each array is from 0 to len - 1.
 
-{\bf Note:}
-
+\note{
 Before calling this function, the program needs to initialise the system
 to be able to provide this service. This is done by calling the function
 {\bf void CmiInitMultipleSendRoutine(void) }. Unless this function is
 called, the system will not be able to provide the service to the user.
 }
+}
 
 \section{Broadcasting Messages}
 
@@ -499,7 +499,7 @@ just like messages transmitted with Cmi functions.  Note that unlike
 the Cmi send functions, these cannot move messages across processors.
 
 Every message inserted into the queue has a priority associated with
-it.  Converse priorities are arbitrary-precision numbers between 0 and
+it.  \converse{} priorities are arbitrary-precision numbers between 0 and
 1.  Priorities closer to 0 get processed first, priorities closer to 1
 get processed last.  Arbitrary-precision priorities are very useful in
 AI search-tree applications. Suppose we have a heuristic suggesting
@@ -526,7 +526,7 @@ of the integer.
 
 Some people only want regular integers as priorities.  For
 simplicity's sake, we provide an easy way to convert integer
-priorities to Converse's built-in representation.
+priorities to \converse{}'s built-in representation.
 
 In addition to priorities, you may choose to enqueue a message
 ``LIFO'' or ``FIFO''.  Enqueueing a message ``FIFO'' simply pushes it
@@ -537,7 +537,7 @@ priority.
 Messages sent using the CMI functions take precedence over everything
 in the scheduler queue, regardless of priority.
 
-A recent addition to Converse scheduling mechanisms is the introduction of
+A recent addition to \converse{} scheduling mechanisms is the introduction of
 node-level scheduling designed to support low-overhead programming for the
 SMP clusters. These functions have ``Node'' in their names. All processors
 within the node has access to the node-level scheduler's queue, and thus
@@ -655,26 +655,26 @@ node-level queue is empty, zero otherwise.}
 \section{Polling for Messages}
 \label{polling}
 
-As we stated earlier, Converse messages trigger handler functions when
+As we stated earlier, \converse{} messages trigger handler functions when
 they arrive.  In fact, for this to work, the processor must
-occasionally poll for messages.  When the user starts Converse, he can
+occasionally poll for messages.  When the user starts \converse{}, he can
 put it into one of several modes.  In the normal mode, the message
 polling happens automatically.  However {\em user-calls-scheduler}
 mode is designed to let the user poll manually.  To do this, the user
 must use one of two polling functions: CmiDeliverMsgs, or
 CsdScheduler.  CsdScheduler is more general, it will notice any
-Converse event.  CmiDeliverMsgs is a lower-level function that ignores
+\converse{} event.  CmiDeliverMsgs is a lower-level function that ignores
 all events except for recently-arrived messages.  (In particular, it
 ignores messages in the scheduler queue).  You can save a tiny amount
 of overhead by using the lower-level function.  We recommend the use
 of CsdScheduler for all applications except those that are using only
-the lowest level of Converse, the Cmi.  A third polling function,
+the lowest level of \converse{}, the Cmi.  A third polling function,
 CmiDeliverSpecificMsg, is used when you know the exact event you want
 to wait for: it does not allow any other event to occur.
 
 \function {void CsdScheduler(int NumberOfMessages)}
 \index{CsdScheduler}
-\desc{This call invokes the Converse scheduler, which repeatedly
+\desc{This call invokes the \converse{} scheduler, which repeatedly
 delivers messages to their handlers (i.e. invokes the handler for each
 message it selects).  In each iteration, the scheduler first looks for
 any message that has arrived from another processor, and delivers it.
@@ -738,7 +738,7 @@ for idle and busy norifications.}
 idle (\param{fIdle}) or busy (\param{fBusy}). These functions can be
 overridden with another call to CsdSetNotifyIdle.}
 
-\internal{
+\zap{
 \section{Global Pointer}
 
 \function{int CmiGptrCreate(GlobalPtr *gptr, void *lptr, unsigned int size)}
@@ -821,7 +821,7 @@ send and blocking receive.}
 On machines with host, this is implemented on top of the messaging 
 layer using asynchronous sends.}
 
-\internal{
+\zap{
 \section{Processor Groups}
 
 \function{void CmiPgrpCreate(Pgrp *group)}
@@ -866,7 +866,7 @@ array should at least be of size \param{CmiNumChildren()}.}
 \section{Spanning Tree Calls}
 
 Sometimes, it is convenient to view the processors/nodes of the machine as a
-tree.  For this purpose, Converse defines a tree over processors/nodes.  We
+tree.  For this purpose, \converse{} defines a tree over processors/nodes.  We
 provide functions to obtain the parent and children of each processor/node.  On
 those machines where the communication topology is relevant, we
 arrange the tree to optimize communication performance. The root of
index 91fd90df7bc6737ac6b24b11513fbfccbfc4eb23..46e404a2399969acc8b8cd418f281bc3393e0847 100644 (file)
@@ -6,13 +6,10 @@ This module provides functions that allow users to insert hooks,
 i.e. user-supplied functions, that are called by the system at
 specified times, or as specific conditions arise.
 
-{\bf  CcdCallOnCondition}
-\begin{verbatim}
-void CcdCallOnCondition(condnum,fnp,arg)
-    int condnum;
-    CcdVoidFn fnp;
-    void *arg;      
-\end{verbatim}
+\function{void CcdCallOnCondition(condnum,fnp,arg)}
+\args{int condnum;}
+\args{CcdVoidFn fnp;}
+\args{void *arg;}
 
 This call instructs the system to call the function indicated by the
 function pointer {\tt fnp}, with the specified argument {\tt arg}, when the
@@ -29,12 +26,8 @@ PROGRAM), which is raised by the system when there are no entities
 (ready threads, messages for objects, posted handlers, etc.) in the
 scheduler's queue.
 
-\vspace*{0.2in}
-{\bf  CcdRaiseCondition}
-\begin{verbatim}
-void CcdRaiseCondition(condNum)
-     int condNum;
-\end{verbatim}
+\function{void CcdRaiseCondition(condNum)}
+\args{int condNum;}
 
 When this function is called, it invokes all the functions whose
 pointers were registered for the \verb#condNum# via a {\em prior} call
@@ -45,13 +38,9 @@ function is called, it loses its registration.  So, if users want the
 function to be called the next time the same condition arises, they
 must register the function again.
 
-\vspace*{0.2in}
-{\bf  CcdPeriodicallyCall}
-\begin{verbatim}
-void CcdPeriodicallyCall(fnp, arg)
-    CcdVoidFn fnp;
-    void *arg;  
-\end{verbatim}
+\function{void CcdPeriodicallyCall(fnp, arg)}
+\args{CcdVoidFn fnp;}
+\args{void *arg;}
 
 A function registered through this call is called periodically by the
 system's scheduler.  Typically, it would be called every time the
@@ -60,14 +49,10 @@ thread or before scheduling a message for an object, or before calling
 a posted handler. These functions don't have to be re-registered after
 every call, unlike the functions for the "conditions". 
 
-\vspace*{0.2in}
-{\bf  CcdCallFnAfter}
-\begin{verbatim}
-void CcdCallFnAfter(fnp, arg, deltaT)
-    CcdVoidFn fnp;
-    void *arg;
-    unsigned int deltaT; 
-\end{verbatim}
+\function{void CcdCallFnAfter(fnp, arg, deltaT)}
+\args{CcdVoidFn fnp;}
+\args{void *arg;}
+\args{unsigned int deltaT;}
 
 This call registers a function via a pointer to it, {\tt fnp},  that will be
 called at least {\tt deltaT} milliseconds later. 
index ff54ff1420141c00dd929ed186062d259f6817c3..a799b42691bb71ea8e7a03041c7a6297e19227f0 100644 (file)
@@ -1,50 +1,3 @@
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% RCS INFORMATION:
-%
-%       $RCSfile$
-%       $Author$        $Locker$                $State$
-%       $Revision$      $Date$
-%
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% DESCRIPTION:
-%
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% REVISION HISTORY:
-%
-% $Log$
-% Revision 1.10  1999-07-29 20:50:37  milind
-% Added node-level functions.
-%
-% Revision 1.9  1997/07/29 20:55:30  milind
-% Updated machine model chapter and merged it with Cmi chapter.
-%
-% Revision 1.8  1997/07/19 23:51:52  wilmarth
-% Several changes to correct/clarify test were made.
-%
-% Revision 1.7  1997/06/26 05:16:22  jyelon
-% Still improving manual.
-%
-% Revision 1.6  1997/06/25 06:53:48  jyelon
-% Just trying to make this whole manual make more sense.
-%
-% Revision 1.5  1995/11/16 22:11:11  milind
-% removed hardwired reference.
-%
-% Revision 1.4  1995/11/01  21:16:23  milind
-% Added index entries.
-%
-% Revision 1.3  1995/10/30  17:33:54  milind
-% Changed Cth variables macros to Ctv macros.
-% Added "More on Shared Memory Machines" section.
-%
-% Revision 1.2  1995/10/27  21:02:54  milind
-% Integrated into Manual.
-%
-% Revision 1.1  1995/10/26  21:08:23  gursoy
-% Initial revision
-%
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
 \section{Global Variables and Utility functions}
 \label{globalvars}
 
@@ -58,11 +11,11 @@ each thread has its own copy of the global variables.
 The lack of consistency across vendors, makes it very hard to write a
 portable program.  The fact that most vendors make the globals shared
 is inconvenient as well, usually, you don't want your globals to be
-shared.  For these reasons, we added ``pseudoglobals'' to Converse.
+shared.  For these reasons, we added ``pseudoglobals'' to \converse{}.
 These act much like C global and static variables, except that you have
 explicit control over the degree of sharing.
 
-\subsection{Converse PseudoGlobals}
+\subsection{\converse{} PseudoGlobals}
 
 Three classes of pseudoglobal variables are supported: node-private,
 process-private, and thread-private variables.
@@ -82,20 +35,19 @@ and access. The declaration, static and extern specifications have the
 same meaning as in C. In order to support portability, however, the
 global variables must be installed properly, by using the
 initialization macros.  For example, if the underlying machine is a
-simulator for the machine model supported by Converse, then the
+simulator for the machine model supported by \converse{}, then the
 thread-private variables must be turned into arrays of variables.
 Initialize and Access macros hide these details from the user.  It is
 possible to use global variables without these macros, as supported by
 the underlying machine, but at the expense of portability.
 
 Macros for node-private variables:
-\begin{verbatim}
-CsvDeclare(type,variable)
-CsvStaticDeclare(type,variable)
-CsvExtern(type,variable)
-CsvInitialize(type,variable)
-CsvAccess(variable)
-\end{verbatim}
+
+\function{CsvDeclare(type,variable)}
+\function{CsvStaticDeclare(type,variable)}
+\function{CsvExtern(type,variable)}
+\function{CsvInitialize(type,variable)}
+\function{CsvAccess(variable)}
 
 \index{CsvDeclare}
 \index{CsvStaticDeclare}
@@ -104,13 +56,13 @@ CsvAccess(variable)
 \index{CsvAccess}
 
 Macros for process-private variables:
-\begin{verbatim}
-CpvDeclare(type,variable)
-CpvStaticDeclare(type,variable)
-CpvExtern(type,variable)
-CpvInitialize(type,variable)
-CpvAccess(variable)
-\end{verbatim}
+
+\function{CpvDeclare(type,variable)}
+\function{CpvStaticDeclare(type,variable)}
+\function{CpvExtern(type,variable)}
+\function{CpvInitialize(type,variable)}
+\function{CpvAccess(variable)}
+
 \index{CpvDeclare}
 \index{CpvStaticDeclare}
 \index{CpvExtern}
@@ -118,13 +70,13 @@ CpvAccess(variable)
 \index{CpvAccess}
 
 Macros for thread-private variables:
-\begin{verbatim}
-CtvDeclare(type,variable)
-CtvStaticDeclare(type,variable)
-CtvExtern(type,variable)
-CtvInitialize(type,variable)
-CtvAccess(variable)
-\end{verbatim}
+
+\function{CtvDeclare(type,variable)}
+\function{CtvStaticDeclare(type,variable)}
+\function{CtvExtern(type,variable)}
+\function{CtvInitialize(type,variable)}
+\function{CtvAccess(variable)}
+
 \index{CtvDeclare}
 \index{CtvStaticDeclare}
 \index{CtvExtern}
@@ -150,32 +102,32 @@ called at the beginning of execution to complete the installations of
 all global variables.
 
 \begin{figure}
-\begin{verbatim}
-File Module1.c
+\begin{alltt}
+File: Module1.c
 
     typedef struct point
-    {
+    \{
          float x,y;
-    } Point;
+    \} Point;
 
 
     CpvDeclare(int, a);
     CpvDeclare(Point, p);
 
     void ModuleInit()
-    {
+    \{
          CpvInitialize(int, a)
          CpvInitialize(Point, p);
 
          CpvAccess(a) = 0;
-    }
+    \}
 
     int func1() 
-    {
+    \{
          CpvAccess(p).x = 0;
          CpvAccess(p).y = CpvAccess(p).x + 1;
-    }
-\end{verbatim}
+    \}
+\end{alltt}
 \caption{An example code for global variable usage}
 \label{fig:cpv}
 \end{figure}
@@ -184,7 +136,7 @@ File Module1.c
 \label{utility}
 
 To further simplify programming with global variables on shared memory
-machines, Converse provides the following functions and/or
+machines, \converse{} provides the following functions and/or
 macros. \note{These functions are defined on machines other than
 shared-memory machines also, and have the effect of only one processor
 per node and only one thread per processor.}
@@ -231,7 +183,7 @@ processors belonging to the node participate in this barrier.}
 
 \function{typedef McDependentType CmiNodeLock}
 \index{CmiNodeLock}
-\desc{This is the type for all the node-level locks in Converse.}
+\desc{This is the type for all the node-level locks in \converse{}.}
 
 \function{CmiNodeLock CmiCreateLock(void)}
 \index{CmiCreateLock}
@@ -258,7 +210,7 @@ then compete for acquiring \param{lock}.}
 \desc{Frees any memory associated with \param{lock}. It is an error to
 perform any operations with \param{lock} after a call to this function.}
 
-\internal{
+\zap{
 \function{void *CmiSvAlloc(int size)}
 \index{CmiSvAlloc}
 \desc{Allocates a block of memory of \param{size} bytes from the heap in node's 
index de078eafd60e9fde548d9b8be9efecaafdac72ee..d35d1ad7ccf0f18e6b0b264e984606e790fd02d4 100644 (file)
@@ -1,86 +1,21 @@
-\documentclass[11pt]{report}
-
-\newif\ifpdf
-\ifx\pdfoutput\undefined
-  \pdffalse
-\else
-  \pdfoutput=1
-  \pdftrue
-\fi
-
-\ifpdf
-  \pdfcompresslevel=9
-  \usepackage[pdftex,colorlinks=true,plainpages=false]{hyperref}
-\else
-\fi
-
-\setcounter{topnumber}{2}
-\def\topfraction{1}
-\setcounter{bottomnumber}{1}
-\def\bottomfraction{1}
-\setcounter{totalnumber}{3}
-\def\textfraction{0.2}
-\def\floatpagefraction{0.8}
-\setlength{\parindent}{0.0in}
-\setlength{\parskip}{0.1in}
-\setlength{\textwidth}{6.5in}
-\setlength{\itemindent}{1in}
-\setlength{\textheight}{9.5in}
-\addtolength{\oddsidemargin}{0in}
-\addtolength{\topmargin}{-0.4in}
-\parskip 0.05in
-\newcommand{\internal}[1]{}
-\newcommand{\function}[1]{{\noindent{\bf {#1}}\\}}
-\newcommand{\param}[1]{{\tt {#1}}}
-\newcommand{\note}[1]{\noindent{(Note: {\em {#1}})}}
-\newcommand{\desc}[1]{{#1}}
-
-\newcommand{\basea}{\renewcommand{\baselinestretch}{1.0}}
-\newcommand{\baseb}{\renewcommand{\baselinestretch}{1.8}}
-\newcommand{\mycomment}[1]{} 
-\basea
-\textwidth 6.4in
-\textheight 8.9in
-\topmargin -.4in
-\oddsidemargin 0.25in
-\evensidemargin 0.25in
-\parskip 0.1in
-
-\makeindex
-
-\begin{document}
-
-\begin{titlepage}
-\vspace*{2in}
-\Huge
-\begin{center}
-Converse\\
-Programming\\
-Manual\\
-\vspace*{0.7in}
-\today
-\end{center}
-\normalsize
-
-\vspace*{2.5in}
-\large
-
-Converse Parallel Programming Environment was developed as a group
+\documentclass[10pt]{report}
+\usepackage{pplmanual}
+\input{../pplmanual}
+
+\title{\converse{}\\Programming\\Manual}
+\version{5.5}
+\credits{
+\converse{} Parallel Programming Environment was developed as a group
 effort at Parallel Programming Laboratory, University of Illinois at
 Urbana-Champaign.  The team consisted of Attila Gursoy, Sanjeev
 Krishnan, Joshua Yelon, Milind Bhandarkar, Narain Jagathesan, Robert
-Brunner and Laxmikant Kale. The most recent version of Converse has had inputs
+Brunner and Laxmikant Kale. The most recent version of \converse{} has had inputs
 from Milind Bhandarkar, Laxmikant Kale, Robert Brunner, Terry Wilmarth,
 Parthasarathy Ramachandran, Krishnan Varadarajan, and Jeffrey Wright.
+}
 
-\normalsize
-\end{titlepage}
-
-\tableofcontents
+\begin{document}
+\maketitle
 
 \input{usermain}
 \input{cmi}
index 88485cf7774c550b06e6fc076ae036918ee2abb7..e17a5b4949d7c209e2f2cfbe7c380643f1fafacf 100644 (file)
@@ -1,7 +1,7 @@
 Running with the simulator:
 
 
-Converse provides a simple parallel machine simulator for developing
+\converse{} provides a simple parallel machine simulator for developing
 and debugging purposes. It simulates a message passing system. The simulated
 machine is a collection of processing nodes connected with a communication
 network. Each node is composed of an application processor, local memory, and 
@@ -9,7 +9,7 @@ a communication coprocessor.
 The simulator is a beta version, particularly using the simulator timers
 for performance measurements has not been tested yet.
 
-In order to run Converse programs with the simulator:
+In order to run \converse{} programs with the simulator:
 \begin{item}
 \item link user program with <machine>/lib/libck-unimain.o
 \item prepare a configuration file as described below
@@ -87,14 +87,14 @@ is given below:
 \item[\verb+processor_scale+] The simulator scales the measured time
                       execution of code-blocks by this value.
 
-\item[\verb+periodic_interval+] Converse has periodic checks for
+\item[\verb+periodic_interval+] \converse{} has periodic checks for
                       various purposes. This is the time on seconds
                       those checks are called.
 \end{description}
 
 
 \begin{figure}
-\begin{verbatim}
+\begin{alltt}
 #latency parameters
 cpu_recv_cost 1E-6 1E-7              
 cpu_send_cost 1E-6 1E-7
@@ -129,7 +129,7 @@ latency-fixed
 
 processor_scale 1.0
 periodic_interval 0.1
-\end{verbatim}
+\end{alltt}
 \caption{A sample configuration file for the simulator}
 \label{fig:simconfig}
 \end{figure}
index 2f87f4e0d9dd7aac5e61cfb20df77bcc646802bf..8570a18fd437582562433f680e888d331ae72383 100644 (file)
@@ -112,12 +112,12 @@ together into queues.  This function sets the contents of the next field.}
 
 \section{Thread Scheduling and Blocking Restrictions}
 
-Converse threads use a scheduler queue, like any other threads
-package.  We chose to use the same queue as the one used for Converse
+\converse{} threads use a scheduler queue, like any other threads
+package.  We chose to use the same queue as the one used for \converse{}
 messages (see section \ref{schedqueue}).  Because of this, thread
 context-switching will not work unless there is a thread polling for
-messages.  A rule of thumb, with Converse, it is best to have a thread
-polling for messages at all times.  In Converse's normal mode (see
+messages.  A rule of thumb, with \converse{}, it is best to have a thread
+polling for messages at all times.  In \converse{}'s normal mode (see
 section \ref{initial}), this happens automatically.  However, in
 user-calls-scheduler mode, you must be aware of it.
 
@@ -129,16 +129,16 @@ blocking operations in these places:
 
 \begin{itemize}
 
-\item{In the code of a Converse handler (see sections \ref{handler1}
+\item{In the code of a \converse{} handler (see sections \ref{handler1}
 and \ref{handler2}).}
 
-\item{In the code of the Converse start-function (see section
+\item{In the code of the \converse{} start-function (see section
 \ref{initial}).}
 
 \end{itemize}
 
 These restrictions are usually easy to avoid.  For example, if you
-wanted to use a blocking operation inside a Converse handler, you
+wanted to use a blocking operation inside a \converse{} handler, you
 would restructure the code so that the handler just creates a new
 thread and returns.  The newly-created thread would then do the work
 that the handler originally did.
@@ -146,7 +146,7 @@ that the handler originally did.
 \section{Thread Scheduling Hooks}
 
 Normally, when you CthAwaken a thread, it goes into the primary
-ready-queue: namely, the main Converse queue described in section
+ready-queue: namely, the main \converse{} queue described in section
 \ref{schedqueue}.  However, it is possible to hook a thread to make
 it go into a different ready-queue.  That queue doesn't have to be
 priority-queue: it could be FIFO, or LIFO, or in fact it could handle
@@ -232,7 +232,7 @@ of the scheduling module, it is permitted for the scheduling module to
 resume {\tt t} whenever it so desires: presumably, the scheduling
 module knows when its threads want the CPU.
 
-\internal{
+\zap{
 \function{void CthSetVar(CthThread t, void **var, void *val)}
 \desc{Specifies that the global variable pointed to by {\tt
 var} should be set to value {\tt val} whenever thread {\tt t} is
@@ -242,12 +242,12 @@ thread-private data with thread {\tt t}.
 
 it is intended that this function be used as follows:}
 
-\begin{verbatim}
+\begin{alltt}
     /* User defines a struct th_info containing all the thread-private  */
     /* data he wishes to associate with threads.  He also defines       */
     /* a global variable 'current_thread_info' which will always hold   */
     /* the th_info of the currently-executing thread.                   */
-    struct th_info { ... } *current_thread_info;
+    struct th_info \{ ... \} *current_thread_info;
 
     /* User creates a thread 't', and allocates a block of memory       */
     /* 'tinfo' to hold the thread's private data.  User tells the       */
@@ -258,7 +258,7 @@ it is intended that this function be used as follows:}
     t = CthCreate( ... );
     tinfo = (struct th_info *)malloc(sizeof(struct th_info));
     CthSetVar(t, &current_thread_info, tinfo);
-\end{verbatim}
+\end{alltt}
 
 \desc{Note: you can use CthSetVar multiple times on a thread, thereby
 attaching multiple data items to it.  However, each data item slows
index 21cac4bee9678c9563ea7a0e37e1ce5ec872dd86..0fde61b8d1df7846d88fe99f3da5035121dd5ba3 100644 (file)
@@ -1,19 +1,19 @@
 \chapter{Initialization and Completion}
 \label{initial}
 
-The program utilizing Converse begins executing at {\tt main}, like
+The program utilizing \converse{} begins executing at {\tt main}, like
 any other C program.  The initialization process is somewhat
 complicated by the fact that hardware vendors don't agree about which
 processors should execute {\tt main}.  On some machines, every processor
 executes {\tt main}.  On others, only one processor executes {\tt
 main}.  All processors which don't execute {\tt main} are asleep when
 the program begins.  The function ConverseInit is used to start the
-Converse system, and to wake up the sleeping processors.
+\converse{} system, and to wake up the sleeping processors.
 
 \function{typedef void (*CmiStartFn)(int argc, char **argv);}
 \function{void ConverseInit(int argc, char *argv[], CmiStartFn fn, int usched, int initret)}
 \index{ConverseInit}
-\desc{This function starts up the Converse system.  It can execute
+\desc{This function starts up the \converse{} system.  It can execute
 in one of the modes described below.
 
 Normal Mode: {\tt schedmode=0, initret=0}
@@ -21,19 +21,19 @@ Normal Mode: {\tt schedmode=0, initret=0}
 When the user runs a program, some of the processors automatically invoke
 {\tt main}, while others remain asleep.  All processors which automatically
 invoked {\tt main} must call ConverseInit.  This initializes the
-entire Converse system.  Converse then initiates, on {\em all}
+entire \converse{} system.  \converse{} then initiates, on {\em all}
 processors, the execution of the user-supplied start-function {\tt
-fn(argc, argv)}.  When this function returns, Converse automatically
+fn(argc, argv)}.  When this function returns, \converse{} automatically
 calls {\tt CsdScheduler}, a function that polls for messages and
 executes their handlers (see chapter 2).  Once {\tt CsdScheduler}
-exits on all processors, the Converse system shuts down, and the user's
+exits on all processors, the \converse{} system shuts down, and the user's
 program terminates.  Note that in this case, ConverseInit never
 returns.  The user is not allowed to poll for messages manually.
 
 User-calls-scheduler Mode: {\tt schedmode=1, initret=0}
 
 If the user wants to poll for messages and other events manually, this
-mode is used to initialize Converse.  In normal mode, it is assumed
+mode is used to initialize \converse{}.  In normal mode, it is assumed
 that the user-supplied start-function {\tt fn(argc, argv)} is just for
 initialization, and that the remainder of the lifespan of the program
 is spent in the (automatically-invoked) function {\tt CsdScheduler},
@@ -41,7 +41,7 @@ polling for messages.  In user-calls-scheduler mode, however, it is
 assumed that the user-supplied start-function will perform the {\em
 entire computation}, including polling for messages.  Thus,
 ConverseInit will not automatically call {\tt CsdScheduler} for you.
-When the user-supplied start-function ends, Converse shuts down.  This
+When the user-supplied start-function ends, \converse{} shuts down.  This
 mode is not supported on the sim version.  This mode can be combined
 with ConverseInit-returns mode below.}
 
@@ -49,9 +49,9 @@ ConverseInit-returns Mode: {\tt schedmode=1, initret=1}
 
 This option is used when you want ConverseInit to return.  All
 processors which automatically invoked {\tt main} must call
-ConverseInit.  This initializes the entire Converse System.  On all
+ConverseInit.  This initializes the entire \converse{} System.  On all
 processors which {\em did not} automatically invoke {\tt main},
-Converse initiates the user-supplied initialization function {\tt
+\converse{} initiates the user-supplied initialization function {\tt
 fn(argc, argv)}.  Meanwhile, on those processors which {\em did}
 automatically invoke {\tt main}, ConverseInit returns.  Shutdown is
 initiated when the processors that {\em did} automatically invoke {\tt
index 98c68b6b43d0928875c97bcfed5f36208315b632..74447d98f0c4ba85a7976fff2b11df3f44bcca18 100644 (file)
@@ -25,3 +25,5 @@
 \newcommand{\kw}[1]{{\textsf{#1}}}
 \newcommand{\uw}[1]{{\textsl{#1}}}
 \newcommand{\desc}[1]{\indent{#1}}
+\newcommand{\note}[1]{(\textbf{Note:} #1)}
+