[Swift-commit] r2410 - text/hpdc09submission

[noreply at svn.ci.uchicago.edu]

Author: benc
Date: 2009-01-09 05:06:15 -0600 (Fri, 09 Jan 2009)
New Revision: 2410

Modified:
   text/hpdc09submission/paper.latex
Log:
procedures are called procedures, not functions. some rearrangements of text

Modified: text/hpdc09submission/paper.latex
===================================================================
--- text/hpdc09submission/paper.latex	2009-01-09 09:23:32 UTC (rev 2409)
+++ text/hpdc09submission/paper.latex	2009-01-09 11:06:15 UTC (rev 2410)
@@ -97,21 +97,19 @@
 and other arguments that are the inputs and outputs of each program
 invocation. This formal but simple specification of data inputs and
 outputs enables Swift to provide four critical features not provided
-by scripting languages like Perl, Python, Tcl, or the various command-line ``shells'':
+by scripting languages like Perl, Python, or the various command-line shells:
 
 \begin{itemize}
 \item It can provide location transparent execution: automatically
-selecting a location (i.e. a specific distributed system) for a given
-program invocation
-\item It can automatically parallelize (and throttle) the execution flow
+selecting a location for a given program invocation
+\item It can automatically parallelize the execution flow
 of program invocations, executing invocations that have no data
-dependencies in parallel.
-\item It can record the provenance of derived data objects (and related
-caller-callee information)
-\item The Swift execution engine records the progress of a script's
-execution, so if interrupted or terminated, it can be restarted from
-the point of interruption, without re-executing any work that was
-logged as successfully completed.
+dependencies in parallel, whilst throttling parallel invocations to a rate
+appropriate for each execution location
+\item It can record the provenance of derived data objects
+\item It can provide reliability through retrying of failed executions during
+a run and by logging completed work so that an interrupted script can be
+restarted from the point of interruption.
 \end{itemize}
 
 In the rest of this section, we provide an overview of Swift's main
@@ -132,7 +130,7 @@
 implemented. This specification is instead left up to a set of
 mappers.
 
-\emph{Execution of atomic functions}. Underlying this is an
+\emph{Execution of atomic procedures}. Underlying this is an
 implementation to execute scripts on grid and other platforms,
 providing built-in site selection, data management and
 reliability. Swift scripts can be tested on a single local
@@ -146,7 +144,7 @@
 several benefits. A notable benefit visible to users is that of
 providers. This enbles the Swift execution model to be extended by
 adding new data providers and job execution providers. This is
-explained in more detail in section X: Swift Implementation.
+explained in more detail in section \ref{ExecutingSites}: Executing on a remote site.
 
 \emph{Minimalist nature of Swift}. As a scripting language, Swift is
 intentionally designed to be a sparse, minimal language. Its primary
@@ -165,28 +163,26 @@
 Swift programs typically contain very little code to manipulate data
 directly.
 
-\emph{Function composition and Libraries}. Swift programs are composed
-starting with ``atomic'' functions, and then higher level functions are
-composed as pipelines of sub-functions. The basic structure of a
-composite function is a graph of calls to other functions.
+\emph{Procedure composition and Libraries}. Swift programs are composed
+starting with ``atomic'' procedures, and then higher level procedures are
+composed as pipelines of sub-procedures. The basic structure of a
+composite procedure is a graph of calls to other procedures.
 
-Recursive function calls [are / are not] supported  [TODO: Relevant?]
-
 \emph{Variables, single assignment and data flow}. Swift variables hold
 primitive values, or references to datasets, which are files or
 collections of files. Variables are ``single assignment'', which is the
-basis for Swift's model of function chaining. Functions are executed
-when their variables are all set. Functions are chained by specifying
-that an output variable of one function is passed as the input
-variable to the second function.
+basis for Swift's model of procedure chaining (TODO execution ordering?). Procedures are executed
+when their input variables are all set. Procedures are chained by specifying
+that an output variable of one procedure is passed as the input
+variable to the second procedure.
 
-This dataflow model means that within a Swift program, functions are
+This dataflow model means that within a Swift program, procedures are
 executed when their data is available - which is not necessarily in
 source-code order.
 
-Swift function arguments are lists of such variables, and return lists
+Swift procedure arguments are lists of such variables, and return lists
 of such variables. Swift does not yet have a notion of
-libraries. Swift programs execute as if all functions called in the
+libraries. Swift programs execute as if all procedures called in the
 script are present in a single logical source file and are thus passed
 to the Swift virtual machine all at once.
 
@@ -232,7 +228,7 @@
 automatically make remote execution transparent.
 
 In a sense, Swift adds to scripting what RPC adds to programming: by
-formalizing the inputs and outputs of ``applications-as-functions'', it
+formalizing the inputs and outputs of ``applications-as-procedures'', it
 provides a way to make the remote - and hence parallel - execution of
 applications fairly transparent.
 
@@ -243,10 +239,6 @@
 set of data. Unlike make, in which case the derived product is only
 produced once, in Swift, derived datasets are repetitively derived.
 
-Could existing programs execute Swift calls through a library
-approach?  The answer to this is certainly ``yes'', and we examine this
-in more detail in section X.
-
 Usage of Swift. Swift is achieving growing use on a variety of science
 problems.
 
@@ -729,6 +721,7 @@
 interesting?
 
 \subsection{Executing on a remote site}
+\label{ExecutingSites}
 
   With the above restrictions, execution of a unix program on a remote
 site is straightforward. The Swift runtime must prepare a remote
@@ -1256,6 +1249,11 @@
 on what is available now - logprocessing module, as well as
 mentioning CEDPS\cite{CEDPS} as somewhat promising(?) for the future.
 
+\subsection{Swift as a library}
+Could existing programs execute Swift calls through a library
+approach?  The answer to this is certainly ``yes''. (?)
+
+
 \section{Implementation status}
 
   TODO: list how Swift can be downloaded here. describe development group?
@@ -1272,7 +1270,7 @@
 legacy applications), were coded in various programming languages and
 run in different platforms and architectures.  Linda defines a set of
 coordination primitives for concurrent agents to put and retrieve
-tuples from a shared data space called tuplespace, which serves as the
+tuples from a shared data space called a tuple space, which serves as the
 medium for communication and coordination. Strand and PCN use
 single-assignment variables\cite{singleassigment} as coordination mechanism. Like Linda,
 Strand and PCN are data driven in the sense that the action of sending