[Swift-commit] r3886 - text/parco10submission

[noreply at svn.ci.uchicago.edu]

Author: wilde
Date: 2011-01-07 00:11:55 -0600 (Fri, 07 Jan 2011)
New Revision: 3886

Modified:
   text/parco10submission/paper.tex
Log:
resolved remoaining notes. Misc additional edits.

Modified: text/parco10submission/paper.tex
===================================================================
--- text/parco10submission/paper.tex	2011-01-07 05:48:18 UTC (rev 3885)
+++ text/parco10submission/paper.tex	2011-01-07 06:11:55 UTC (rev 3886)
@@ -358,15 +358,13 @@
 pipelines (or more generally, graphs) of sub-functions.
 
 Unlike most other scripting languages, Swift expresses
-invocations of ``ordinary programs''---technically, POSIX {\tt exec()}
-operations---in a manner that explicitly declares the files and command-line
+invocations of ``ordinary programs''--technically, POSIX {\tt exec()}
+operations--in a manner that explicitly declares the files and command-line
 arguments that are the inputs of each program
 invocation.  Swift scripts similarly declare all output files that results from program invocations.
 This enables Swift to provide distributed, location-independent execution of external application programs.
 
-The Swift parallel execution model is based on two concepts that are applied uniformly throughout the language. First, every Swift data element behaves like a \emph{future}. By ``data element'', we mean both the named variables within a function's environment, such as its local variables, parameters, and returns, and the individual elements of array and structure collections. Second, all expressions in a Swift program are conceptually executed in parallel. Expressions (including function evaluations) wait for input values when they are required, and then set their result values as their computation proceeds. These fundamental concepts are discussed in more detail below.
-\mikenote{This concept is a major highlight of the swift programming model - I meant to highlight it under "Execution model" but did not. We should do so.}
-% can be thought of as a massively-parallel lazy (ie, on-demand, or just in time) evaluation - say later on?
+The Swift parallel execution model is based on two concepts that are applied uniformly throughout the language. First, every Swift data element behaves like a \emph{future}. By ``data element'', we mean both the named variables within a function's environment, such as its local variables, parameters, and returns, and the individual elements of array and structure collections. Second, all expressions in a Swift program are conceptually executed in parallel. Expressions (including function evaluations) wait for input values when they are required, and then set their result values as their computation proceeds. These fundamental concepts of pervasive implicit parallelism and transparent location independence, along with natural manner in which Swift expresses the processing of files by applications as if they were ``in-memory'' objects, are the powerful aspects of Swift which make it unique among scripting tools. These aspects are elaborated in this section.
 
 \subsection{Data model}
 
@@ -650,11 +648,12 @@
    z=q(y);
 \end{verbatim}
 
-Arrays in Swift are treated as collections of simple variables, in the sense that all array elements are single-assignment.
+\hide{Arrays in Swift are treated as collections of simple variables, in the sense that all array elements are single-assignment.
 Once the value of an array element is
 set, then it cannot change. When all the values for the array which can be set (as determined by limited flow analysis) are
-set, then the array is regarded as \emph{closed}. 
-\katznote{the few lines before this in this paragraph have been repeated from earlier in the section.}  Statements that
+set, then the array is regarded as \emph{closed}.}
+
+Statements that
 deal with the array as a whole will wait for the array to be closed
 before executing. An example of such an action is the expansion of the array values into an app command line.
 Thus, the closing of an array is the equivalent to setting a future variable, with respect to any statement that was waiting for the array itself to be assigned a value. However, a \verb|foreach| statement
@@ -949,7 +948,7 @@
 \section{Execution engine}
 \label{Execution}
 
-Swift is implemented by compiling to a Karajan program~\cite{Karajan}, which provides
+Swift is implemented by generating and executing a Karajan program~\cite{Karajan}, which provides
 several benefits: a lightweight threading model,
 futures,
 remote job execution,
@@ -957,10 +956,10 @@
 remote file transfer and data management.
 Both remote execution and data transfer and management functions are provided through generalized
 abstracted interfaces called \emph{providers}~\cite{Karajan}.
-Data providers enable data transfer and management to be performed through a wide variety of protocols including direct local copying, GridFTP, HTTP, WebDAV, SCP, and FTP.
-Execution providers enable job execution to take place using direct POSIX process fork, Globus GRAM, Condor (and Condor-G), PBS, SGE, SSH.
-The Swift execution model can thus be extended by
-adding new data providers and job execution providers.
+\emph{Data providers} enable data transfer and management to be performed through a wide variety of protocols including direct local copying, GridFTP, HTTP, WebDAV, SCP, and FTP.
+\emph{Execution providers} enable job execution to take place using direct POSIX process fork, Globus GRAM, Condor (and Condor-G), PBS, SGE, and SSH services.
+The Swift execution model can be flexibly extended for novel and evolving computing environments by
+implementing new data providers and/or job execution providers.
 
 \subsection{Executing on a remote site}
 \label{ExecutingSites}