The Fortress Language Specification - CiteSeerX

• A field with value type is assigned by copying, and thus has the sharedness of the containing object or closure.
Publishing can be expensive, particularly if the structure being broadcast is large and heavily nested; this can cause an
apparently short atomic expression (a single write, say) to run arbitrarily long. To avoid this, the library programmer
can request that an object be published by calling the semantically transparent function shared :
x := shared Cons(x,xs)
shared(y)
A local copy of an object can be obtained by calling copy , a method on trait Object:
localVar := sharedVar.copy()
Two additional methods are provided which permit different choices of program behavior based on the sharedness of
objects:
• The getter o.isShared returns true when o is shared, and false when it is local. This permits the program to
take different actions based on sharedness.
• Method o.localize() is equivalent to the following expression:
if o.isShared then o.copy() else o end
These methods must be used with extreme caution. For example, localize should be used only when there is a unique
reference to the object being localized. The localize method can have unexpected behavior if there is a reference to o
from another local object p . Updates to o will be visible through p ; subsequent publication of p will publish o . By
contrast, if o was already shared, and referred to by another shared object, the newly-localized copy will be entirely
distinct; changes to the copy will not be visible through p , and publishing p will not affect the locality of the copy.
32.5 Distributions
Most of the heavy lifting in mapping threads and arrays to regions is performed by distributions. An instance of the
trait Distribution describes the parallel structure of ranges and other numeric generators (such as the generators for
the index space of an array), and provides for the allocation and distribution of arrays on the machine:
trait Distribution extends Object
distributeT extends ArrayIndex(RangeT) :RangeT
distributeE, B extends ArrayIndex(a :ArrayE, B) :ArrayE, B =
distributeFromToE, B(a, a.distribution,self)
end
Abstractly, a Distribution acts as a transducer for generators and arrays. The distribute method applied to a multidimensional
Range organizes its indices into the leaves of a tree whose inner nodes correspond to potential levels
of parallelism and locality in the underlying computation, producing a fresh Range whose behavior as a Generator
may differ from that of the passed-in Range. The distribute method applied to an array creates a copy of that
array distributed according to the given distribution. This is specified in terms of a call to the overloaded function
distributeFromTo . This permits the definition of specialized versions of this function for particular pairs of distributions.
The intention of distributions is to separate the task of data distribution and program correctness. That is, it should be
possible to write and debug a perfectly acceptable parallel program using only the default data distribution provided
by the system. Imposing a distribution on particular computations, or designing and implementing distributions from
scratch, is a task best left for performance tuning, and one which should not affect the correctness of a working
program.
218