Several changes to correct/clarify test were made.
authorTerry L. Wilmarth <wilmarth@uiuc.edu>
Sat, 19 Jul 1997 23:51:49 +0000 (23:51 +0000)
committerTerry L. Wilmarth <wilmarth@uiuc.edu>
Sat, 19 Jul 1997 23:51:49 +0000 (23:51 +0000)
doc/converse/cmi.tex
doc/converse/cpm.tex
doc/converse/cpvmacros.tex
doc/converse/ldb.tex
doc/converse/msgmgr.tex
doc/converse/threads.tex
doc/converse/usermain.tex

index 7041fa614259e0da65dfc281172817c54e6b99d1..228d7b1d0043f19014ca213f54608b45b692c030 100644 (file)
@@ -21,7 +21,7 @@ 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
-to do, nonetheless, the user must be aware that this is (usually)
+to do, nonetheless, and the user must be aware that this is (usually)
 required.
 
 The following functions are provided to define the handler numbers:
@@ -169,7 +169,7 @@ continues working in the background.  The background job transfers the
 data from the message buffer into the network.  Since the background job
 is still using the message buffer when the function returns, you can't
 reuse the message buffer immediately.  The background job sets a flag
-when it is done and you can reuse the message buffer.}
+when it is done and you can then reuse the message buffer.}
 
 \item{{\bf sync and free}: a version that returns almost instantaneously,
 and then continues working in the background.  The background job
@@ -374,7 +374,7 @@ priority.}
 The message is enqueued with the middle priority ``1000...'', and is
 pushed behind all other messages with this priority.}
 
-\item{{\tt CQS\_QUEUEING\_FIFO}: the prioptr and priobits are ignored.
+\item{{\tt CQS\_QUEUEING\_LIFO}: the prioptr and priobits are ignored.
 The message is enqueued with the middle priority ``1000...'', and is
 pushed in front of all other messages with this priority.}
 
@@ -517,7 +517,7 @@ and usually has at least microsecond accuracy.}
 
 \function{int CmiNumPe(void)}
 \index{CmiNumPe}
-\desc{Returns total number of processors in the machine on which the 
+\desc{Returns the total number of processors on which the 
 parallel program is being run.}
 
 \function{int CmiMyPe(void)}
index 2add5f7298656ee774f9c378bea71dddfa3dc069..27a329bcabcbaff2bff36415ef83339058d893e9 100644 (file)
@@ -35,21 +35,21 @@ The launcher has this prototype:
     void Cpm_myfunc(CpmDestination destination, int x, int y);
 \end{verbatim}
 
-If I were to call {\tt Cpm\_myfunc} as follows:
+If one were to call {\tt Cpm\_myfunc} as follows:
 
 \begin{verbatim}
     Cpm_myfunc(CpmSend(3), 8, 9);
 \end{verbatim}
 
-A message would be sent to processor 3 ordering it to call {\tt
+a message would be sent to processor 3 ordering it to call {\tt
 myfunc(8,9)}.  Notice that the {\it destination} argument isn't just an
 integer processor number.  The possible destinations for a message are
 described later.
 
 When the CPM scanner is applied to a C source file with a particular
-name, it generates a great deal of parameter packing and unpacking
-code, and this code is inserted into an include file with a name
-similar to the original C file: the {\tt .c} is replaced with {\tt
+name, it generates a certain amount of parameter packing and unpacking
+code, and this code is placed in an include file named
+similarly to the original C file: the {\tt .c} is replaced with {\tt
 .cpm.h}.  The include file must be included in the original {\tt .c}
 file, after the declarations of the types which are being packed and
 unpacked, but before all uses of the CPM invocation mechanisms.
@@ -68,7 +68,6 @@ is the responsibility of the CPM user to call each of these {\tt
 CpmInitializeThisModule} functions before using any of the CPM
 mechanisms.
 
-
 We demonstrate the use of the CPM mechanisms using the following
 short program {\tt myprog.c}:
 
@@ -108,7 +107,7 @@ the {\it i}'th processor.
 
 The effect of this program is that the first processor orders each of
 the other processors to print a random number.  Note that the example
-is somewhat minimalist, for example, it doesn't contain any code for
+is somewhat minimalist since it doesn't contain any code for
 terminating itself.  Also note that it would have been more efficient
 to use an explicit broadcast.  Broadcasts are described later.
 
@@ -172,7 +171,7 @@ example,
 Cpm_print_integer(CpmMakeThread(CPM_ALL), 5);
 \end{verbatim}
 
-Would broadcast a message to all the processors causing each processor
+would broadcast a message to all the processors causing each processor
 to create a thread, which would in turn invoke {\tt print\_integer}
 with the argument 5.
 
@@ -201,7 +200,7 @@ CpmDim} argument to be the size of the array.  Given a pointer to the
 array, its size, and its element-type, CPM handles the packing of
 array values as automatically as it handles single values.
 
-Here is a second program, {\tt example2.c}, which uses array arguments:
+A second program, {\tt example2.c}, uses array arguments:
 
 \begin{verbatim}
  1:    #include "example2.cpm.h"
@@ -354,9 +353,9 @@ Note that the inclusion of the {\tt .cpm.h} file comes after these
 type and pack declarations: the {\tt .cpm.h} file will reference these
 functions and macros, therefore, they must already be defined.
 
-\section{Inventing new kinds of CpmDestinations}
+\section{Inventing New Types of CpmDestinations}
 
-It is possible for the user to invent new kinds of CpmDestinations,
+It is possible for the user to create new types of CpmDestinations,
 and to write functions that return these new destinations.  In order
 to do this, one must have a mental model of the steps performed when a
 Cpm message is sent.  This knowledge is only necessary to those
@@ -551,6 +550,6 @@ It can access the envelope of the message using CpmEnv:
     int *CpmEnv(void *msg);
 \end{verbatim}
 
-And it can also access the data stored in the destination-structure
+It can also access the data stored in the destination-structure
 by the destination-function.
 
index efb66c9b75f1197b0e0367d05cdae52a650db6b8..26ee697edfae395576965685e4776e5891d0daca 100644 (file)
 % REVISION HISTORY:
 %
 % $Log$
-% Revision 1.7  1997-06-26 05:16:22  jyelon
+% 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
@@ -39,7 +42,7 @@
 \chapter{Machine Model and Global Variables}
 
 Converse treats the parallel machine as a collection of nodes, where
-each node comprises of a number of processors that share memory.  In
+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.  In
 addition, each of the processors may have multiple threads running on
 them which share code and data but have different stacks.
@@ -130,7 +133,7 @@ CtvAccess(variable)
 
 A sample code to illustrate the usage of the macros is provided
 in Figure~\ref{fig:cpv}.
-There are a few rules that user must pay attention: The
+There are a few rules that the user must pay attention to: The
 {\tt type} and {\tt variable} fields of the macros must be a single
 word. Therefore, structures or pointer types can be used by defining
 new types with the {\tt typedef}. In the sample code, for example,
@@ -179,11 +182,11 @@ File Module1.c
 \section{Utility Functions}
 \label{utility}
 
-To further simplify programming with global variables on shared memory machines,
-Converse provides 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.}
+To further simplify programming with global variables on shared memory
+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.}
 
 \function{int CmiMyRank()}
 \index{CmiMyRank}
index acb5c93f7d3e7ad3459b74763e4f5e07b2278e6b..5f42ac77e36d1ea179d240d9cdfd491727c98cc6 100644 (file)
@@ -3,12 +3,11 @@
 Converse provides the programmer with a number of Load Balancing
 strategies in order to distribute work among the processors in the
 system. The load balancing strategy to be used in the program can be
-specified at the link time. \note{In the future versions, we will
-provide the users with ability to write their own load balancing
+specified at the link time. \note{In future versions, we will
+provide users with the ability to write their own load balancing
 strategies. However, in this version, the choice is limited to certain
-predefined load balancing strategies.} Following functions are provided
-for interfacing the converse program with the load balancing module of
-Converse.
+predefined load balancing strategies.} The following functions are provided
+for interfacing a Converse program with the load balancing module.
 
 \function{void CldNewSeedFromLocal(void *msg, void *ldb, void (*sendfn)(),int queueing, int priolen, int *prioptr)}
 \index{CldNewSeedFromLocal}
@@ -43,14 +42,14 @@ different use of the parameter \param{ldb}. Some of the currently
 implemented language specific load balancing strategies use this area
 in the message for sending the load information on local processor
 piggy-backed onto the message periodically; some of them may not need
-this area at all. \note{The only ldb strategy available to converse
+this area at all. \note{The only ldb strategy available to Converse
 users currently, i.e. random, does not use this area and the user could
 specify \param{void * (0))} there.}
 
-Some of the parallel languages or libraries built on top of converse
+Some of the parallel languages or libraries built on top of Converse
 may have the message packing mechanisms which have to be called before
 any message crosses address boundaries. Therefore the load balancing
-module cannot use the built-in function such as \param{CmiAsyncSend()}
+module cannot use built-in functions such as \param{CmiAsyncSend()}
 for sending the work off to another processor. For this reason, the
 user needs to specify a function \param{sendfn()} which takes two
 parameters:  \param{void *msgptr} and \param{int destPE}. Languages or
index 3d7b5d19234ddbf6dfb6bf2975d49f45ffe05034..86fa44787d6ea4057f5703097ec5184d8e397265 100644 (file)
@@ -55,7 +55,7 @@ To ``match'', the array {\tt tags} must be of the same length as the
 stored array.  Similarly, all the individual tags in the stored array
 must ``match'' the tags in the {\tt tags} array.  Two tags match if they
 are equal to each other, or if {\tt either} tag is equal to {\tt
-CmmWildCard} (yes, that means if I can {\tt store} messages with
+CmmWildCard} (this means one can {\tt store} messages with
 wildcard tags, making it easier to find those messages on retrieval).}
 
 \function{void *CmmProbe(CmmTable t, int ntags, int *tags, int *ret\_tags)}
index 6a433572847d48a73c1e840035cbae60c0cf79ab..7514d3feebf9ac1bc3085e04877f096453b94854 100644 (file)
@@ -3,7 +3,7 @@
 The calls in this chapter can be used to put together runtime systems
 for languages that support threads.
 This threads package, like most thread packages, provides basic
-functionality like creating threads, destroying threads, yielding, 
+functionality for creating threads, destroying threads, yielding, 
 suspending, and awakening a suspended thread. In
 addition, it provides facilities whereby you can write your own thread
 schedulers.  
@@ -57,7 +57,7 @@ CthThread}.}
 \desc{Frees thread {\tt t}.  You may ONLY free the
 currently-executing thread (yes, this sounds strange, it's
 historical).  Naturally, the free will actually be postponed until the
-thread suspends.  This is how a thread terminates itself: it calls
+thread suspends.  To terminate itself, a thread calls
 {\tt CthFree(CthSelf())}, then gives up control to another thread.}
 
 \function{void CthSuspend()}
index bcbb635595c9c643e14eca9bf1ae734e59a6a6e4..497c53783aaea96dda9f4c99fb46f781ec58e613 100644 (file)
@@ -7,32 +7,32 @@ 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
-in one of several modes, described below.
+in one of the modes described below.
 
 Normal Mode: {\tt usched=0, initret=0}
 
-When you run your program, some of the processors automatically invoke
-{\tt main}, others remain asleep.  All processors which automatically
-invoked {\tt main} must must call ConverseInit.  This initializes the
+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}
 processors, the execution of the user-supplied start-function {\tt
 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 your
+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 usched=1, initret=0}
 
-This is how the user initializes Converse if he wants to poll for
-messages and other events manually.  In normal mode, it is assumed
+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
 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},
@@ -42,7 +42,7 @@ 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
 mode is not supported on the sim version.  This mode can be combined
-with ConverseInit returns mode below.}
+with ConverseInit-returns mode below.}
 
 ConverseInit-returns Mode: {\tt usched=1, initret=1}
 
@@ -61,6 +61,6 @@ supported by the sim version.
 
 \function{void ConverseExit(void)}
 \index{ConverseExit}
-\desc{This function is only used in ConverseInit returns mode, see
+\desc{This function is only used in ConverseInit-returns mode, described
 above.}