[Swift-commit] r3915 - text/parco10submission

[noreply at svn.ci.uchicago.edu]

Author: wozniak
Date: 2011-01-08 18:38:02 -0600 (Sat, 08 Jan 2011)
New Revision: 3915

Modified:
   text/parco10submission/paper.tex
Log:
Include dds plot


Modified: text/parco10submission/paper.tex
===================================================================
--- text/parco10submission/paper.tex	2011-01-09 00:37:20 UTC (rev 3914)
+++ text/parco10submission/paper.tex	2011-01-09 00:38:02 UTC (rev 3915)
@@ -366,11 +366,11 @@
 
 \subsection{Data model and types}
 
-Variables are used in Swift to name the local variables, arguments, and returns of a function. 
-The outermost function in a Swift (akin to ``main'' in C) is only unique in that the variables in its environment 
+Variables are used in Swift to name the local variables, arguments, and returns of a function.
+The outermost function in a Swift (akin to ``main'' in C) is only unique in that the variables in its environment
 can be declared ``global'' to make them accessible to every other function in the script.
 
-Each variable in a Swift script is declared to be of a specific (single) type. The Swift type model is simple, with no concepts of inheritance, abstraction, etc. 
+Each variable in a Swift script is declared to be of a specific (single) type. The Swift type model is simple, with no concepts of inheritance, abstraction, etc.
 There are three basic classes of data types: primitive, mapped, and collection.
 
 \emph{Primitive types} are provided for integer, float, string, and boolean values. Common operators are defined for
@@ -387,7 +387,7 @@
 Arrays use numeric indices, but are sparse.
 Both types of collections can contain members of primitive, mapped, or collection types;
 in particular, arrays can be nested to provide multi-dimensional indexing.
-Structures contain a declared number of elements. The number of elements in an array can be determined at run time. 
+Structures contain a declared number of elements. The number of elements in an array can be determined at run time.
 
 New types can be declared to define a new mapped type or to name a structure type. The type model is by design very simple and limited to keep type semantics easy to understand, implement and use.
 
@@ -424,8 +424,8 @@
 \end{verbatim}
 
 The notation \verb|{}| indicates that the type represents a reference to a single \emph{opaque}
-file, i.e., a reference to an external object whose structure is opaque to the Swift script. 
-For convenience such type declarations typically use the equivalent shorthand \verb|type image;| 
+file, i.e., a reference to an external object whose structure is opaque to the Swift script.
+For convenience such type declarations typically use the equivalent shorthand \verb|type image;|
 (this compact notation is confusing at first but has become a useful Swift idiom).
 
 Mapped type variable declarations can be specified with a
@@ -464,8 +464,8 @@
 Swift's \emph{built-in functions} are implemented by the Swift runtime system, and perform various utility functions (numeric conversion, string manipulation, etc.). Built-in operators (+, *, etc.) behave similarly.
 
 An \emph{application interface function} (declared using the \verb|app| keyword)
-specify both the interface (input files and parameters; output files) of an application program, 
-and the command line syntax used to invoke the program. It thus provides the information that the Swift runtime requires 
+specify both the interface (input files and parameters; output files) of an application program,
+and the command line syntax used to invoke the program. It thus provides the information that the Swift runtime requires
 to invoke that program in a location independent manner.
 
 For example, the following application interface function declaration defines a Swift function {\tt rotate} that uses
@@ -480,8 +480,8 @@
    }
 \end{verbatim}
 
-Having defined this function, we can now build a complete Swift script that rotates a file  
-{\tt puppy.jpeg} by 180 degrees to generate the file {\tt rotated.jpeg}: 
+Having defined this function, we can now build a complete Swift script that rotates a file
+{\tt puppy.jpeg} by 180 degrees to generate the file {\tt rotated.jpeg}:
 
 \begin{verbatim}
    type image;
@@ -501,7 +501,7 @@
 output parameters, and variables to the right of the function
 invocation passed as inputs.
 
-This script can be invoked from the command line, as in the following example, 
+This script can be invoked from the command line, as in the following example,
 in which Swift executes a single \verb|convert| command, while automatically performing for the user features
 such as remote multisite execution and fault tolerance, as discussed later.
 
@@ -537,7 +537,7 @@
 \subsection{Arrays and parallel execution}
 \label{ArraysAndForeach}
 
-Arrays are declared using the \verb|[]| suffix. 
+Arrays are declared using the \verb|[]| suffix.
 For example, we declare here an array containing three strings and then use the
  \verb|foreach| construct to apply a function {\tt analyze} to each element of that array.
 (The arguments {\tt fruit} and {\tt index} resolve to an array element, and that element's index, respectively.)
@@ -623,7 +623,7 @@
 
 We have described almost all of the Swift language. (Swift also provides conditional
 execution through the \emph{if} and \emph{switch} statements.)
-The Swift execution model is simple. 
+The Swift execution model is simple.
 Through the use of futures, functions become executable
 when their input parameters have all been set, either from existing
 data or prior function executions.  Function calls may be chained by
@@ -920,7 +920,7 @@
 directory or one of its subdirectories, the program can expect to find
 all files passed as inputs to the application block;
 and on exit, it should leave all files named by that application block
-in the same working directory. 
+in the same working directory.
 
 Applications should not assume
 that they will be executed on a particular host (to facilitate site
@@ -1253,7 +1253,7 @@
 it would cause the first five elements of the array {\tt geos} to be mapped to the first five files of the modis dataset in the specified directory.
 
 At lines 52-53, the script declares the array {\tt land} which will contain the output of the {\tt getlanduse} application. This declaration uses the built-in ``structured regular expression mapper'', which will determine the names of the \emph{output} files that the array will refer to once they are computed. Swift knows from context that this is an output mapping. The mapper will use regular expressions to base that names of the output files on the filenames of the corresponding elements of the input array {\tt geos} given by the {\tt source=} argument to the mapper.
- 
+
  At lines 55-57 the script performs its first computation using a {\tt foreach} loop to invoke {\tt getLandUse} in parallel on each file mapped to the elements of {\tt geos[]}. As 317 files were mapped (in lines 47-48), the loop will invoke 317 instances of the application in parallel. \katznote{is this strictly true?  Do you want to say that it will enable 317 instances to be runnable in parallel, but the number that are actually run in parallel depends on the hardware available to Swift, or something like that?} The result of each computation is placed in a file mapped to the array {\tt land} and named by the regular expression translation to be based on the file names mapped to the array {\tt geos[]} (in lines \katznote{is this 52-53?}). Thus the landuse histogram for file {\tt /home/wilde/modis/2002/h00v08.tif} would be written into file {\tt h00v08.landuse.freq} and would be considered by Swift to be of type {\tt landuse}.
 
 Once all the land usage histograms have have been computed, the script can then execute {\tt analyzeLandUse} at line 63 to find the requested number of highest tiles (files) with a specific land cover combination. The Swift runtime system uses futures to ensure that this analysis function is not invoked until all of its input files have computed and transported to the computation site chosen to run the analysis program. All of these steps take place automatically, using the relatively simple and location-independent Swift expressions shown. The output files to be use to hold the result are specified in the declarations at lines 61-62. \katznote{should these lines have a space inserted before the ``<'' to match the previous lines?  Same question for 67-68... }
@@ -1331,6 +1331,14 @@
   \end{center}
 \end{figure*}
 
+\begin{figure*}[htbp]
+  \begin{center}
+    \includegraphics[scale=0.70]{plots/dds}
+    \caption{System utilization for variable length tasks
+              at varying concurrency}
+    \label{PlotDDS}
+  \end{center}
+\end{figure*}
 
 \section{Related Work}
 \label{Related}
@@ -1678,4 +1686,4 @@
 derivative works, distribute copies to the public, and perform
 publicly and display publicly, by or on behalf of the Government.
 
-\end{document}
\ No newline at end of file
+\end{document}