The Fortress Language Specification - CiteSeerX

v = spawn at a.region(i) do
a i
end
w = spawn at v.region() do
v.val() · 17
end
Finally, note that it is possible to use an at expression within a block:
do
v := a i
at a.region(j) do
w := a j
end
x = v + w
end
We can think of this as the degenerate case of also do : a thread group is created with a single implicit thread running
the contents of the at expression in the given region; when this thread completes control returns to the original
location.
Note that the regions given in an at expression are non-binding: the Fortress implementation may choose to run the
computations elsewhere—for example, thread migration might not be possible within an atomic expression, or load
balancing might cause code to be executed in a different region. In general, however, implementations should attempt
to respect thread placement annotations when they are given.
32.8 Use and Definition of Generators
Several expressions in Fortress make use of generator lists (given by the nonterminal GeneratorList in the Fortress
grammar defined in Appendix G) to express parallel iteration (see Section 13.17). A generator list binds a series of
variables to the values produced by a series of objects with the Generator trait. A generator list is simply syntactic
sugar for a nested series of invocations of methods on these objects. All the parallelism provided by a particular
generator is specified by its definitions for the methods of the Generator trait. In general, the library code for a
generator dictates the parallel structure of computations involving that generator.
The definition of trait Generator has very simple functionality at its core:
trait Generator E
size : Z64
generate R extends Monoid R, ⊕ ,opr ⊕ (body : E → R) : R
join N (other : Generator N ) : Generator (E, N) =
SimplePairGenerator E, N (self,other)
end
The mechanics of object generation are embedded entirely in the generate method. This method takes one argument,
the body function. The generate method invokes body once for each object which is to be generated, passing the
generated object as an argument. Note that body returns a value in some Monoid R; the results of the calls to body
are combined using the monoid operator ⊕ . This reduction may include any number of occurrences of the identity
of the monoid—in particular, a generator may generate no elements, in which case it will never invoke body and will
simply the identity.
A simple definition of a Generator need only define the size field and the generate method:
221