The Fortress Language Specification - CiteSeerX

T R, ⊞[ ] body = body
T R, ⊞[ x ← g,gs ]body = g.generateR, ⊞(fn () ⇒ T R, ⊞[gs]body)
T R, ⊞[ p , gs ] body = if p then (T R, ⊞[gs]body) else Identity⊞ end
Figure 32.1: Naive and simple desugaring of generator lists using only the generate method.
value object BlockedRange(lo: Z64,hi: Z64, b: Z64) extends GeneratorZ64
size : Z64 = hi − lo + 1
generateR extends Monoid R, ⊕,opr ⊕(body : Z64 → R) : R =
if size ≤ max(b, 1) then
r : R = Identity⊕
i : Z64 = lo
if i ≤ hi then
label done do
while true do
r := r ⊕ body(i)
if i ≥ hi then exit done with () end
i += 1
end
end
end
r
else
mid = ⌈lo/2⌉ + ⌊hi/2⌋
BlockedRange(lo,mid, b).generate(body)⊕
BlockedRange(mid + 1,hi, b).generate(body)
end
end
This example generates the integers between lo and hi inclusive. It does this using recursive subdivision. Recursive
subdivision is the recommended technique for exposing large amounts of parallelism in a Fortress program because
it adjusts easily to varying machine sizes and can be dynamically load balanced. In this example we divide the range
in half if it is larger than the block size b ; these two halves are computed in parallel (recall that the arguments to an
operator are evaluated in parallel). If the range is smaller than b , then it is enumerated serially using a while loop,
accumulating the result r as it goes.
The remainder of this section describes in detail the desugaring of generator lists and expressions with generators into
invocations of the generate and join methods of the generators in the generator list. It then outlines how method
overloading may be used to specialize the behavior of particular combinations of generators and reductions.
32.8.1 Simple Desugaring of Expressions with Generators
Each expression with generators is desugared into the following general form:
wrapper(fn () ⇒ T R, ⊞[gs ]body)
where the desugaring must provide appropriate instantiations of wrapper , body , and the reduction static parameters,
R and ⊞ . A simple and easily-understood desugaring “ T R, ⊞[gs ]body ” for generator lists is shown in Figure 32.1.
The desugaring of GeneratorList takes three parameters: a block of static parameters, R and ⊞ , the actual generator
list (which we enclose in square brackets), and the body expression which should be used. Here and in subsequent
desugarings, v in v ← g can stand either for a single variable or for a tuple of variables. We convert the
222