Manual Patch: More Wordsmithing and Formatting
Jeffrey
oldham at mail.codesourcery.com
Tue Jan 29 21:49:48 UTC 2002
2002-Jan-29 Jeffrey D. Oldham <oldham at codesourcery.com>
These changes to the POOMA manual continue the process of working
toward delivery. Most of the changes involve wordsmithing and
formatting of the PostScript version.
* arrays.xml: Fix formatting. Minor wording changes.
* concepts.xml: Likewise.
* data-parallel.xml: Change section title. Fix formatting of
verbatim sections.
* introduction.xml: Change use of the word "free." Other minor
wording and formatting changes.
* manual.xml: Update download page entity. Add acknowledgements.
Fix use of the word "Unix." Fix some formatting, particularly
verbatim environments.
* template.xml: Be consist in use of "programming time." Minor
formatting and wordsmithing.
* tutorial.xml: Replace use of "Unix." Fix formatting.
Applied to mainline
Approved by me.
Thanks,
Jeffrey D. Oldham
oldham at codesourcery.com
-------------- next part --------------
Index: arrays.xml
===================================================================
RCS file: /home/pooma/Repository/r2/docs/manual/arrays.xml,v
retrieving revision 1.4
diff -c -p -r1.4 arrays.xml
*** arrays.xml 2002/01/25 02:28:25 1.4
--- arrays.xml 2002/01/29 18:11:18
***************
*** 239,248 ****
<title>Declaring &domain;s</title>
<para>Since &domain;s are mainly used to declare container
! domains, we focus on declaring &domain;s. We subsequently
! describe a few &domain; operations but most, including arithmetic
! operations with &domain;s, are described in <xref
! linkend="views"></xref>.</para>
<para>All &domain; declarations require a dimension template
parameter <varname>&dim;</varname>. This positive integer
--- 239,248 ----
<title>Declaring &domain;s</title>
<para>Since &domain;s are mainly used to declare container
! domains, we focus on declaring &domain;s, deferring most
! discussion of their use. We subsequently describe a few &domain;
! operations but most, including arithmetic operations with
! &domain;s, are described in <xref linkend="views"></xref>.</para>
<para>All &domain; declarations require a dimension template
parameter <varname>&dim;</varname>. This positive integer
*************** Grid<1> g(list);
*** 1099,1109 ****
<!-- FIXME: This paragraph is poorly worded. -->
<para>&array; values need not just be stored values, as &c; arrays
! have. They can also be computed by its engine. We defer
! discussion of computing values to the next chapter discussing
! engines (<xref linkend="engines"></xref>). To avoid being verbose
! in this chapter, when we discuss stored values, the values might
! instead be computed.</para>
<para>Declaring an &array; requires four arguments: the domain's
dimensionality, the type of values stored or computed, a
--- 1099,1110 ----
<!-- FIXME: This paragraph is poorly worded. -->
<para>&array; values need not just be stored values, as &c; arrays
! have. The values can also be computed dynamically by the engine
! associated with the &array;. We defer discussion of computing
! values to the next chapter discussing engines (<xref
! linkend="engines"></xref>). Therefore, when we mention <quote>the
! values stored in an &array;</quote>, we implicitly mean <quote>the
! values stored in or computed by the &array;</quote>.</para>
<para>Declaring an &array; requires four arguments: the domain's
dimensionality, the type of values stored or computed, a
*************** Array<2,bool> c(2,3, ModelElement&
*** 1395,1401 ****
seven &double;s all equaling π, use
<programlisting>
const double pi = 4.0*atan(1.0);
! Array<1,double,CompressibleBrick> d(7, ModelElement<double>(pi));.
</programlisting> We use a &compressiblebrick; &engine;, rather than
a &brick; &engine;, so all seven values will be stored in one
location rather than in seven separate locations when they are all the
--- 1396,1403 ----
seven &double;s all equaling π, use
<programlisting>
const double pi = 4.0*atan(1.0);
! Array<1,double,CompressibleBrick>
! d(7, ModelElement<double>(pi));.
</programlisting> We use a &compressiblebrick; &engine;, rather than
a &brick; &engine;, so all seven values will be stored in one
location rather than in seven separate locations when they are all the
*************** Array<1,double,CompressibleBrick>
*** 1420,1426 ****
// Create an Array and its domain.
Array<2,float,Brick> a(Interval<1>(2,7), Interval<1>(-2,4));
! // Create an Array without a domain and then specify its domain.
Array<2,float,Brick> b();
b.initialize(Interval<1>(2,7), Interval<1>(-2,4));.
</programlisting> Invoking <methodname>initialize</methodname> on an
--- 1422,1429 ----
// Create an Array and its domain.
Array<2,float,Brick> a(Interval<1>(2,7), Interval<1>(-2,4));
! // Create an Array without a domain and then specify
! // its domain.
Array<2,float,Brick> b();
b.initialize(Interval<1>(2,7), Interval<1>(-2,4));.
</programlisting> Invoking <methodname>initialize</methodname> on an
*************** std::cout &openopen; a.read(2,-2) &openo
*** 1623,1629 ****
<varname>a</varname>'s values are the same as <varname>b</varname>
at the time of assignment only. Subsequent changes to
<varname>a</varname>'s values do not change <varname>b</varname>'s
! values or vice versa.</para>
<para>The &array; class has internal type definitions and
constants useful for both compile-time and run-time computations.
--- 1626,1637 ----
<varname>a</varname>'s values are the same as <varname>b</varname>
at the time of assignment only. Subsequent changes to
<varname>a</varname>'s values do not change <varname>b</varname>'s
! values or vice versa. Assignment is more expensive than creating
! a reference. Creating a reference requires creating a very small
! object and incrementing a reference-counted pointer. An
! assignment requires storage for both the left-hand side and
! right-hand side operands and traversing all of the right-hand
! side's data.</para>
<para>The &array; class has internal type definitions and
constants useful for both compile-time and run-time computations.
Index: concepts.xml
===================================================================
RCS file: /home/pooma/Repository/r2/docs/manual/concepts.xml,v
retrieving revision 1.9
diff -c -p -r1.9 concepts.xml
*** concepts.xml 2002/01/25 02:28:26 1.9
--- concepts.xml 2002/01/29 18:11:19
***************
*** 52,60 ****
<tgroup cols="3" align="center">
<thead>
<row>
<entry>Container</entry>
! <entry>Computation Modes</entry>
! <entry>Computation Environment</entry>
</row>
</thead>
<tbody valign="top">
--- 52,65 ----
<tgroup cols="3" align="center">
<thead>
<row>
+ <entry></entry>
+ <entry></entry>
+ <entry>Computation</entry>
+ </row>
+ <row>
<entry>Container</entry>
! <entry>Computation Modes</entry>
! <entry>Environment</entry>
</row>
</thead>
<tbody valign="top">
***************
*** 377,384 ****
are several different types of domains. An <glossterm
linkend="glossary-interval"><firstterm>interval</firstterm></glossterm>
consists of all integral points between two endpoints. It is
! frequently represented using mathematical interval notation [a,b]
! even though it contains only the integral points, e.g., a, a+1,
a+2, …, b. The concept is generalized to multiple
dimensions by forming direct products of intervals, i.e., all the
integral tuples in an &n;-dimensional space. For example, the
--- 382,389 ----
are several different types of domains. An <glossterm
linkend="glossary-interval"><firstterm>interval</firstterm></glossterm>
consists of all integral points between two endpoints. It is
! frequently represented using mathematical interval notation [a,b];
! it contains only the integral points, e.g., a, a+1,
a+2, …, b. The concept is generalized to multiple
dimensions by forming direct products of intervals, i.e., all the
integral tuples in an &n;-dimensional space. For example, the
***************
*** 501,511 ****
involves explicitly accessing a container's values. A data-parallel
computation operates on larger subsets of a container's values.
Stencil-based computations express a computation as repeatedly
! applying a local computation to each element of an array. A
! relation among containers establishes a dependency among them so the
! values of one container are updated whenever any other's values
! change. A program may use any or all of these styles, which are
! described below.</para>
<para><glossterm
linkend="glossary-element_wise"><firstterm>Element-wise</firstterm></glossterm>
--- 506,516 ----
involves explicitly accessing a container's values. A data-parallel
computation operates on larger subsets of a container's values.
Stencil-based computations express a computation as repeatedly
! applying a local computation to each element of an array.
! Relation-based computations use relations on containers to establish
! dependencies among them so the values of one container are updated
! whenever any other's values change. A program may use any or all of
! these styles, which are described below.</para>
<para><glossterm
linkend="glossary-element_wise"><firstterm>Element-wise</firstterm></glossterm>
***************
*** 528,536 ****
data-parallel expressions frequently eliminates the need for writing
explicit loops.</para>
! <para>A <glossterm
! linkend="glossary-stencil"><firstterm>stencil</firstterm></glossterm>
! computes a container's value using neighboring data values. Each
stencil consists of a specification of which neighboring values to
read and a function using those values. For example, an averaging
stencil may access all its adjacent neighbors, averaging them. In
--- 533,541 ----
data-parallel expressions frequently eliminates the need for writing
explicit loops.</para>
! <para>Stencil-based computation uses <glossterm
! linkend="glossary-stencil"><firstterm>stencils</firstterm></glossterm>
! to compute containers' values using neighboring data values. Each
stencil consists of a specification of which neighboring values to
read and a function using those values. For example, an averaging
stencil may access all its adjacent neighbors, averaging them. In
***************
*** 540,548 ****
differential equations, image processing, and geometric
modeling.</para>
! <para>A <glossterm
! linkend="glossary-relation"><firstterm>relation</firstterm></glossterm>
! is a dependence among containers such the dependent container's
values are updated when its values are needed and any of its related
containers' values have changed. A relation is specified by a
dependent container, independent containers, and a function
--- 545,553 ----
differential equations, image processing, and geometric
modeling.</para>
! <para>Relation-based computation uses <glossterm
! linkend="glossary-relation"><firstterm>relations</firstterm></glossterm>
! to create dependences among containers such the dependent container's
values are updated when its values are needed and any of its related
containers' values have changed. A relation is specified by a
dependent container, independent containers, and a function
Index: data-parallel.xml
===================================================================
RCS file: /home/pooma/Repository/r2/docs/manual/data-parallel.xml,v
retrieving revision 1.3
diff -c -p -r1.3 data-parallel.xml
*** data-parallel.xml 2002/01/25 02:28:26 1.3
--- data-parallel.xml 2002/01/29 18:11:20
***************
*** 57,63 ****
<section id="data_parallel-use">
! <title>Their Use</title>
<para>&pooma; containers can be used in data-parallel expressions
and statements. The basic guidelines are simple:
--- 57,63 ----
<section id="data_parallel-use">
! <title>Using Data-Parallel Expressions</title>
<para>&pooma; containers can be used in data-parallel expressions
and statements. The basic guidelines are simple:
*************** std::cout &openopen; A &openopen; std::e
*** 969,981 ****
For example, the overloaded unary minus operator yields a tree
node representing <statement>-A</statement>, having a unary-minus
function object, and having type
! <type>Expression<UnaryNode<OpMinus,Ar&closeclose;</type>.
! The binary nodes continue the construction process yielding a
parse tree object for the entire right-hand side and having type
! <type>Expression<BinaryNode<OpAdd, UnaryNode<OpMinus,
! Ar>,
! BinaryNode<OpMultiply<Scalar<int>,Ar&closecloseclose;</type>.
! Evaluating the left-hand side yields an object
representing <varname>A</varname>.</para>
<figure float="1" id="data_parallel-implementation-pete-tree_figure">
--- 969,983 ----
For example, the overloaded unary minus operator yields a tree
node representing <statement>-A</statement>, having a unary-minus
function object, and having type
! <programlisting>
! Expression<UnaryNode<OpMinus,Ar&closeclose;
! </programlisting> The binary nodes continue the construction process yielding a
parse tree object for the entire right-hand side and having type
! <programlisting>
! Expression<BinaryNode<OpAdd,
! UnaryNode<OpMinus, Ar>,
! BinaryNode<OpMultiply<Scalar<int>,Ar&closecloseclose;
! </programlisting> Evaluating the left-hand side yields an object
representing <varname>A</varname>.</para>
<figure float="1" id="data_parallel-implementation-pete-tree_figure">
*************** struct CreateLeaf<Array<Dim, T, En
*** 1122,1128 ****
<programlisting>
template<int D1,class T1,class E1>
inline typename MakeReturn<UnaryNode<OpUnaryMinus,
! typename CreateLeaf<Array<D1,T1,E1> >::Leaf_t> >::Expression_t
operator-(const Array<D1,T1,E1> & l)
{
typedef UnaryNode<OpUnaryMinus,
--- 1124,1131 ----
<programlisting>
template<int D1,class T1,class E1>
inline typename MakeReturn<UnaryNode<OpUnaryMinus,
! typename CreateLeaf<Array<D1,T1,E1&closeclose;::Leaf_t&closeclose;::
! Expression_t
operator-(const Array<D1,T1,E1> & l)
{
typedef UnaryNode<OpUnaryMinus,
*************** operator-(const Array<D1,T1,E1> &a
*** 1133,1140 ****
</programlisting> <type>Tree_t</type> specifies the node's unique
type. Constructing the object first involves creating a leaf
containing the &array; reference through the call to
! <function>CreateLeaf<Array<D1,T1,E1>
! >::make</function>. The call to
<function>MakeReturn<Tree_t>::make</function> permits
programmers to store trees in different formats. The &pooma;
implementation stores them as <type>Expression</type>s. The
--- 1136,1144 ----
</programlisting> <type>Tree_t</type> specifies the node's unique
type. Constructing the object first involves creating a leaf
containing the &array; reference through the call to
! <programlisting>
! CreateLeaf<Array<D1,T1,E1> >::make
! </programlisting> The call to
<function>MakeReturn<Tree_t>::make</function> permits
programmers to store trees in different formats. The &pooma;
implementation stores them as <type>Expression</type>s. The
*************** for (int i = a's domain[0].first(); i <
*** 1199,1205 ****
performs a <emphasis>compile-time</emphasis> post-order parse-tree
traversal. Its general form is
<programlisting>
! forEach(const Expression& e, const LeafTag& f, const CombineTag& c).
</programlisting> That is, it traverses the nodes of the
<type>Expression</type> object <varname>e</varname>. At
leaves, it applies the operation specified by
--- 1203,1210 ----
performs a <emphasis>compile-time</emphasis> post-order parse-tree
traversal. Its general form is
<programlisting>
! forEach(const Expression& e, const LeafTag& f,
! const CombineTag& c).
</programlisting> That is, it traverses the nodes of the
<type>Expression</type> object <varname>e</varname>. At
leaves, it applies the operation specified by
*************** struct ForEach<UnaryNode<Op, A>
*** 1232,1238 ****
const CTag &c)
{
return Combine1<TypeA_t, Op, CTag>::
! combine(ForEach<A, FTag, CTag>::apply(expr.child(), f, c), c);
}
};
</programlisting> Since this structure is specialized for
--- 1237,1244 ----
const CTag &c)
{
return Combine1<TypeA_t, Op, CTag>::
! combine(ForEach<A, FTag, CTag>::
! apply(expr.child(), f, c), c);
}
};
</programlisting> Since this structure is specialized for
Index: introduction.xml
===================================================================
RCS file: /home/pooma/Repository/r2/docs/manual/introduction.xml,v
retrieving revision 1.4
diff -c -p -r1.4 introduction.xml
*** introduction.xml 2002/01/24 05:11:21 1.4
--- introduction.xml 2002/01/29 18:11:21
***************
*** 33,40 ****
Using these high-level abstractions, the same code runs on a
sequential, parallel, and distributed computers. It runs almost as
fast as carefully crafted machine-specific hand-written programs.
! The &toolkit; is freely available, open-source software compatible
! with any modern &cc; compiler.</para>
<section id="introduction-goals">
--- 33,40 ----
Using these high-level abstractions, the same code runs on a
sequential, parallel, and distributed computers. It runs almost as
fast as carefully crafted machine-specific hand-written programs.
! The &toolkit; is open-source software, available for no cost, and
! compatible with any modern &cc; compiler.</para>
<section id="introduction-goals">
***************
*** 79,85 ****
</indexterm>
The same &pooma; programs run on sequential, distributed, and
parallel computers. No change in source code is required. Two or
! three lines specify how each container's domain should be
distributed among available processors. Using these directives and
run-time information about the computer's configuration, the
&toolkit; automatically distributes pieces of the container domains,
--- 79,85 ----
</indexterm>
The same &pooma; programs run on sequential, distributed, and
parallel computers. No change in source code is required. Two or
! three lines specify how each container's data should be
distributed among available processors. Using these directives and
run-time information about the computer's configuration, the
&toolkit; automatically distributes pieces of the container domains,
***************
*** 283,289 ****
<indexterm zone="introduction-goals-efficient-pete">
<primary>inner-loop evaluation</primary>
</indexterm>
! &pooma; uses &pete; technology to ensure inner loops involving
&pooma;'s object-oriented containers run as quickly as hand-coded
<!-- FIXME: Add a citation to Dr. Dobb's Journal article
pete-99. --> loops. &pete; (the <application>Portable Expression Template
--- 283,289 ----
<indexterm zone="introduction-goals-efficient-pete">
<primary>inner-loop evaluation</primary>
</indexterm>
! &pooma; uses the &pete; Library to ensure inner loops involving
&pooma;'s object-oriented containers run as quickly as hand-coded
<!-- FIXME: Add a citation to Dr. Dobb's Journal article
pete-99. --> loops. &pete; (the <application>Portable Expression Template
*************** A += -B + 2 * C;
*** 303,317 ****
converted, at compile time, to a loop directly evaluating each component of
the result without computing intermediate values.
For example, the code corresponding to the statement above is
! <programlisting>
! vector<double>::iterator iterA = A.begin();
! vector<int>::const_iterator iterB = B.begin();
! vector<double>::const_iterator iterC = C.begin();
! while (iterA != A.end()) {
! *iterA += -*iterB + 2 * *iterC;
! ++iterA; ++iterB; ++iterC;
! }</programlisting>
! Furthermore, since the code is available at compile time, not run time,
it can be further optimized, e.g., moving any loop-invariant code out
of the loop.</para>
--- 303,317 ----
converted, at compile time, to a loop directly evaluating each component of
the result without computing intermediate values.
For example, the code corresponding to the statement above is
! <programlisting>
! vector<double>::iterator iterA = A.begin();
! vector<int>::const_iterator iterB = B.begin();
! vector<double>::const_iterator iterC = C.begin();
! while (iterA != A.end()) {
! *iterA += -*iterB + 2 * *iterC;
! ++iterA; ++iterB; ++iterC;
! }
! </programlisting> Furthermore, since the code is available at compile time, not run time,
it can be further optimized, e.g., moving any loop-invariant code out
of the loop.</para>
*************** A += -B + 2 * C;
*** 330,340 ****
</indexterm>
as
part of the U.S. government's science-based Stockpile Stewardship
! Program
<indexterm>
<primary>Stockpile Stewardship Program</primary>
</indexterm>
! to simulate nuclear weapons. Other applications include a
matrix solver, an accelerator code simulating the dynamics of
high-intensity charged particle beams in linear accelerators, and a
Monte Carlo
--- 330,340 ----
</indexterm>
as
part of the U.S. government's science-based Stockpile Stewardship
! Program.
<indexterm>
<primary>Stockpile Stewardship Program</primary>
</indexterm>
! Other applications include a
matrix solver, an accelerator code simulating the dynamics of
high-intensity charged particle beams in linear accelerators, and a
Monte Carlo
*************** A += -B + 2 * C;
*** 400,406 ****
<section id="introduction-open_source">
! <title>&pooma; is Free, Open-Source Software</title>
<indexterm zone="introduction-open_source">
<primary>open-source software</primary>
--- 400,406 ----
<section id="introduction-open_source">
! <title>&pooma; is Open-Source Software</title>
<indexterm zone="introduction-open_source">
<primary>open-source software</primary>
*************** A += -B + 2 * C;
*** 416,426 ****
available, any programmer may add it. Any programmer can extend it
to solve problems in previously unsupported domains. Companies
using the &toolkit; can read the source code to ensure it has no
! security holes. It may be downloaded for free
and used for perpetuity. There are no annual licenses and no
on-going costs. By keeping their own copies, companies are
guaranteed the software will never disappear. In summary, the
! &poomatoolkit; is free, low-risk software.</para>
</section>
--- 416,426 ----
available, any programmer may add it. Any programmer can extend it
to solve problems in previously unsupported domains. Companies
using the &toolkit; can read the source code to ensure it has no
! security holes. It may be downloaded at no cost
and used for perpetuity. There are no annual licenses and no
on-going costs. By keeping their own copies, companies are
guaranteed the software will never disappear. In summary, the
! &poomatoolkit; is low-risk software.</para>
</section>
Index: manual.xml
===================================================================
RCS file: /home/pooma/Repository/r2/docs/manual/manual.xml,v
retrieving revision 1.10
diff -c -p -r1.10 manual.xml
*** manual.xml 2002/01/25 02:28:26 1.10
--- manual.xml 2002/01/29 18:11:24
***************
*** 2,8 ****
<!-- FIXME: Index this file. -->
<!-- FIXME: What font does DocBook/JadeTeX use? Can we use it for the figures? -->
! <!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN" "file://usr/lib/sgml/docbookx.dtd" [
<!-- Text to Check, Revise, Replace -->
<!-- FIXME: Revise before releasing. -->
--- 2,8 ----
<!-- FIXME: Index this file. -->
<!-- FIXME: What font does DocBook/JadeTeX use? Can we use it for the figures? -->
! <!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN" "file:///usr/lib/sgml/docbookx.dtd" [
<!-- Text to Check, Revise, Replace -->
<!-- FIXME: Revise before releasing. -->
***************
*** 188,194 ****
<!ENTITY poomadownloadpage '<ulink url="http://pooma.codesourcery.com/pooma/download">http://pooma.codesourcery.com/pooma/download</ulink>'>
<!-- The WWW page supporting downloading the &pooma; source code. -->
<!-- UPDATE this URL. -->
! <!ENTITY poomahomepage '<ulink url="http://www.pooma.com/">http://www.pooma.com/</ulink>'>
<!-- The canonical Pooma home page. -->
<!-- UPDATE this filename. -->
<!ENTITY poomasource "pooma-2.3.0">
--- 188,194 ----
<!ENTITY poomadownloadpage '<ulink url="http://pooma.codesourcery.com/pooma/download">http://pooma.codesourcery.com/pooma/download</ulink>'>
<!-- The WWW page supporting downloading the &pooma; source code. -->
<!-- UPDATE this URL. -->
! <!ENTITY poomahomepage '<ulink url="http://www.codesourcery.com/pooma/pooma/">http://www.codesourcery.com/pooma/pooma/</ulink>'>
<!-- The canonical Pooma home page. -->
<!-- UPDATE this filename. -->
<!ENTITY poomasource "pooma-2.3.0">
***************
*** 352,359 ****
<section id="preface-acknowledgements">
<title>Acknowledgements</title>
! <para>Mark Mitchell, Stephen Smith</para>
</section>
</preface>
--- 352,397 ----
<section id="preface-acknowledgements">
<title>Acknowledgements</title>
+ ]]> <!-- end unfinished -->
! <![%temporary;[
! <preface id="acknowledgements">
! <title>Acknowledgements</title>
! ]]> <!-- end temporary -->
!
! <para>This &book; would not have been completed without the help
! and encouragement of a lot of people and organizations. Los Alamos
! National Laboratory funded the writing of this manual and the
! development of the &poomatoolkit;. John Reynders conceived,
! advocated, and headed &pooma; development in its early days, and
! Scott Haney continued the leadership. Susan Atlas, Subhankar
! Banerjee, Timothy Cleland, Julian Cummings, James Crotinger, David
! Forslund, Salman Habib, Scott Haney, Paul Hinker, William Humphrey,
! Steve Karmesin, Graham Mark, Jeffrey D. Oldham, Ji Qiang, John
! Reynders, Robert Ryne, Stephen Smith, M. Srikant, Marydell
! Tholburn, and Timothy Williams all helped develop &pooma;. Rod
! Oldehoeft and Jeff Brown of Los Alamos National Laboratory
! supported CodeSourcery's and Proximation's work, including the
! development of this manual. John Hall, Don Marshall, Jean
! Marshall, and the rest of the BLANCA team at Los Alamos worked
! closely with the developers and provided valuable suggestions for
! improvements.</para>
!
! <para>I am grateful to James Crotinger, Mark Mitchell, and Stephen
! Smith who answered my many questions during the writing of this
! &book;.</para>
!
! <!-- We cheat and abuse an epigraph here. -->
! <epigraph>
! <attribution>Jeffrey D. Oldham, 2002 January</attribution>
! <para></para>
! </epigraph>
!
! <![%temporary;[
! </preface>
! ]]> <!-- end temporary -->
!
! <![%unfinished;[
</section>
</preface>
*************** UNFINISHED</para>
*** 3728,3734 ****
<![%unfinished;[
<para>ADD: Write this section, including extensive instructions
! for Unix, MS Windows, and MacOS. List the configuration options.
Be sure to describe configuring for parallel execution.</para>
]]> <!-- end unfinished -->
--- 3766,3772 ----
<![%unfinished;[
<para>ADD: Write this section, including extensive instructions
! for Unix-like, MS Windows, and MacOS. List the configuration options.
Be sure to describe configuring for parallel execution.</para>
]]> <!-- end unfinished -->
*************** UNFINISHED</para>
*** 3751,3758 ****
example, the &author; uses this library on a two-processor
computer running &linux;. The library, available at <ulink
url="http://www.engelschall.com/sw/mm/">http://www.engelschall.com/sw/mm/</ulink>,
! is available for free and has been successfully tested on a
! variety of Unix platforms.</para>
<para>We describe how to download and install the &mm; library.
<orderedlist spacing="compact">
--- 3789,3796 ----
example, the &author; uses this library on a two-processor
computer running &linux;. The library, available at <ulink
url="http://www.engelschall.com/sw/mm/">http://www.engelschall.com/sw/mm/</ulink>,
! is available at no cost and has been successfully tested on a
! variety of Unix-like platforms.</para>
<para>We describe how to download and install the &mm; library.
<orderedlist spacing="compact">
*************** UNFINISHED</para>
*** 3777,3784 ****
specifying the <command>&dashdash;help</command> option. Since the
&author; prefers to keep all &pooma;-related code in his
<filename class="directory">pooma</filename>subdirectory, he
! uses <command>./configure
! &dashdash;prefix=${HOME}/pooma/mm-1.1.3</command>.</para>
</listitem>
<listitem>
<para>Create the library by issuing the
--- 3815,3824 ----
specifying the <command>&dashdash;help</command> option. Since the
&author; prefers to keep all &pooma;-related code in his
<filename class="directory">pooma</filename>subdirectory, he
! uses
! <programlisting>
! ./configure &dashdash;prefix=${HOME}/pooma/mm-1.1.3
! </programlisting></para>
</listitem>
<listitem>
<para>Create the library by issuing the
*************** UNFINISHED</para>
*** 3825,3836 ****
(FIXME: xref linkend="mpi99", <ulink
url="http://www-unix.mcs.anl.gov/mpi/"></ulink>)
]]> <!-- end unfinished -->
! or the &mm;
! Shared Memory Library. &mpi; works on a wide variety of platforms
! and has achieved widespread usage. &mm; works under Unix on any
! computer with shared memory. Both libraries are available for
! free. The instructions below work for whichever library you
! choose.</para>
<para>We describe how to download and install &cheetah;.
<orderedlist spacing="compact">
--- 3865,3875 ----
(FIXME: xref linkend="mpi99", <ulink
url="http://www-unix.mcs.anl.gov/mpi/"></ulink>)
]]> <!-- end unfinished -->
! or the &mm; Shared Memory Library. &mpi; works on a wide variety
! of platforms and has achieved widespread usage. &mm; works under
! Unix-like operating systems on any computer with shared memory. Both libraries are
! available at no cost. The instructions below work for whichever
! library you choose.</para>
<para>We describe how to download and install &cheetah;.
<orderedlist spacing="compact">
*************** UNFINISHED</para>
*** 3967,3974 ****
<para>Set the &cheetah; directory environment variable
<envar>CHEETAHDIR</envar> to the directory containing the
installed &cheetah; library. For
! example, <command>declare -x
! CHEETAHDIR=${HOME}/pooma/cheetah-1.0</command> specifies the
installation directory used in the previous section. If using
the <application>csh</application> shell, use <command>setenv
CHEETAHDIR ${HOME}/pooma/cheetah-1.0</command>.</para>
--- 4006,4015 ----
<para>Set the &cheetah; directory environment variable
<envar>CHEETAHDIR</envar> to the directory containing the
installed &cheetah; library. For
! example,
! <programlisting>
! declare -x CHEETAHDIR=${HOME}/pooma/cheetah-1.0
! </programlisting> specifies the
installation directory used in the previous section. If using
the <application>csh</application> shell, use <command>setenv
CHEETAHDIR ${HOME}/pooma/cheetah-1.0</command>.</para>
Index: template.xml
===================================================================
RCS file: /home/pooma/Repository/r2/docs/manual/template.xml,v
retrieving revision 1.2
diff -c -p -r1.2 template.xml
*** template.xml 2002/01/24 05:11:21 1.2
--- template.xml 2002/01/29 18:11:25
***************
*** 104,111 ****
values.</para>
<para>All computation not involving run-time input or output can
! occur at program time, compile time, or run time, whichever is
! more convenient. At program time, a programmer can perform
computations by hand rather than writing code to compute it. &cc;
templates are Turing-complete so they can compute anything
computable. Unfortunately, syntax for compile-time computation is
--- 104,111 ----
values.</para>
<para>All computation not involving run-time input or output can
! occur at programming time, compile time, or run time, whichever is
! more convenient. At programming time, a programmer can perform
computations by hand rather than writing code to compute it. &cc;
templates are Turing-complete so they can compute anything
computable. Unfortunately, syntax for compile-time computation is
***************
*** 257,265 ****
<primary>function</primary>
<secondary>application</secondary>
</indexterm>
! A template class is analogous to a
! function. The analogy between compile-time and run-time
! programming constructs can be extended. <xref
linkend="template_programming-template_use-correspondence_table"></xref>
lists these correspondences. For example, at run time, values
consist of things such as integers, floating point numbers,
--- 257,265 ----
<primary>function</primary>
<secondary>application</secondary>
</indexterm>
! A template class is analogous to a function; it is a function from
! types and constants to classes. The analogy between compile-time
! and run-time programming constructs can be extended. <xref
linkend="template_programming-template_use-correspondence_table"></xref>
lists these correspondences. For example, at run time, values
consist of things such as integers, floating point numbers,
*************** struct usuallySimpleClass<false> {
*** 770,778 ****
</indexterm>
creates a file
containing the intermediate code. Unfortunately,
! reading and understanding the code is frequently difficult.
! Perhaps future &cc; compilers will support easy inspection of
! optimized code.</para>
<para>Each category<firstterm></firstterm> of values supports a
distinct set of operations. For example, the run-time category of
--- 770,776 ----
</indexterm>
creates a file
containing the intermediate code. Unfortunately,
! reading and understanding the code is frequently difficult.</para>
<para>Each category<firstterm></firstterm> of values supports a
distinct set of operations. For example, the run-time category of
*************** struct ExpressionTraits<BinaryNode<
*** 834,840 ****
{
typedef typename ExpressionTraits<Left>::Type_t Left_t;
typedef typename ExpressionTraits<Right>::Type_t Right_t;
! typedef typename CombineExpressionTraits<Left_t, Right_t>::Type_t Type_t;
};
</programlisting> consists of a class definition and internal type
definitions. This traits class contains three values, all types
--- 832,839 ----
{
typedef typename ExpressionTraits<Left>::Type_t Left_t;
typedef typename ExpressionTraits<Right>::Type_t Right_t;
! typedef typename
! CombineExpressionTraits<Left_t, Right_t>::Type_t Type_t;
};
</programlisting> consists of a class definition and internal type
definitions. This traits class contains three values, all types
*************** class F {
*** 1027,1035 ****
<operator>+</operator> operator is overloaded to add two &array;s,
which require template parameters to specify:
<programlisting>
! template <int D1,class T1,class E1,int D2,class T2,class E2>
// complicated return type omitted
! operator+(const Array<D1,T1,E1> & l,const Array<D2,T2,E2> & r);
</programlisting> Without using function templates, it would not be
possible to write expressions such as <statement>a1 +
a2</statement>. Member functions can also be templated. This
--- 1026,1036 ----
<operator>+</operator> operator is overloaded to add two &array;s,
which require template parameters to specify:
<programlisting>
! template <int D1,class T1,class E1,
! int D2,class T2,class E2>
// complicated return type omitted
! operator+(const Array<D1,T1,E1> & l,
! const Array<D2,T2,E2> & r);
</programlisting> Without using function templates, it would not be
possible to write expressions such as <statement>a1 +
a2</statement>. Member functions can also be templated. This
*************** template<class T>
*** 1080,1086 ****
struct CreateLeaf
{
typedef Scalar<T> Leaf_t;
! inline static Leaf_t make(const T& a) { return Scalar<T>(a); }
};
</programlisting> Thus,
<function>CreateLeaf<T>::make</function> is a function with
--- 1081,1088 ----
struct CreateLeaf
{
typedef Scalar<T> Leaf_t;
! inline static Leaf_t make(const T& a)
! { return Scalar<T>(a); }
};
</programlisting> Thus,
<function>CreateLeaf<T>::make</function> is a function with
Index: tutorial.xml
===================================================================
RCS file: /home/pooma/Repository/r2/docs/manual/tutorial.xml,v
retrieving revision 1.7
diff -c -p -r1.7 tutorial.xml
*** tutorial.xml 2002/01/24 05:11:21 1.7
--- tutorial.xml 2002/01/29 18:11:25
***************
*** 114,125 ****
]]> <!-- end unfinished -->
<para>In this section, we describe how to obtain, build, and
! install the &poomatoolkit;. We focus on installing under the
! Unix operating system.
<![%unfinished;[
Instructions for installing on computers
running Microsoft Windows or MacOS, as well as more extensive
! instructions for Unix, appear in <xref
linkend="installation"></xref>.
]]> <!-- end unfinished -->
</para>
--- 114,125 ----
]]> <!-- end unfinished -->
<para>In this section, we describe how to obtain, build, and
! install the &poomatoolkit;. We focus on installing under a
! Unix-like operating system.
<![%unfinished;[
Instructions for installing on computers
running Microsoft Windows or MacOS, as well as more extensive
! instructions for Unix-like operating systems, appear in <xref
linkend="installation"></xref>.
]]> <!-- end unfinished -->
</para>
***************
*** 141,147 ****
class="libraryfile">LINUXgcc.conf</filename> supports compiling
under a &linux; operating system with &gcc;, while <filename
class="libraryfile">SGI64KCC.conf</filename> supports compiling
! under a 64-bit <application>SGI</application> Unix operating system
<!-- FIXME: Center the following command. -->
with &kcc;. Next, configure the source code: <command>./configure
&dashdash;arch LINUXgcc &dashdash;opt &dashdash;suite
--- 141,147 ----
class="libraryfile">LINUXgcc.conf</filename> supports compiling
under a &linux; operating system with &gcc;, while <filename
class="libraryfile">SGI64KCC.conf</filename> supports compiling
! under a 64-bit <application>SGI</application> Irix operating system
<!-- FIXME: Center the following command. -->
with &kcc;. Next, configure the source code: <command>./configure
&dashdash;arch LINUXgcc &dashdash;opt &dashdash;suite
***************
*** 715,721 ****
<imagedata fileref="figures/distributed.101" format="EPS" align="center"></imagedata>
</imageobject>
<textobject>
! <phrase>the &pooma; distributed computation model</phrase>
</textobject>
<caption>
<para>The &pooma; distributed computation model creates a layout
--- 715,723 ----
<imagedata fileref="figures/distributed.101" format="EPS" align="center"></imagedata>
</imageobject>
<textobject>
! <phrase>The &pooma; distributed computation model has three
! pieces: partitioning domain, computer configuration, and
! layout.</phrase>
</textobject>
<caption>
<para>The &pooma; distributed computation model creates a layout
***************
*** 793,801 ****
template parameter is <type>Remote</type>. Its <type>Brick</type>
template parameter specifies the &engine; for a particular patch on
a particular context. Most distributed programs use
! <type>MultiPatch<UniformTag, Remote<Brick> ></type> or
! <type>MultiPatch<UniformTag, Remote<CompressibleBrick>
! ></type> &engine;s.</para>
<para>The computations for a distributed implementation are exactly
the same as for a sequential implementation. The &poomatoolkit; and
--- 795,806 ----
template parameter is <type>Remote</type>. Its <type>Brick</type>
template parameter specifies the &engine; for a particular patch on
a particular context. Most distributed programs use
! <programlisting>
! MultiPatch<UniformTag, Remote<Brick&closeclose;
! </programlisting> or
! <programlisting>
! MultiPatch<UniformTag, Remote<CompressibleBrick&closeclose;
! </programlisting> or &engine;s.</para>
<para>The computations for a distributed implementation are exactly
the same as for a sequential implementation. The &poomatoolkit; and
More information about the pooma-dev
mailing list