def test_yreplace_time_invariants(tu, tv, tw, ti0, ti1, t0, t1, exprs, expected):
exprs = EVAL(exprs, tu, tv, tw, ti0, ti1, t0, t1)
counter = generator()
make = lambda: Scalar(name='r%d' % counter()).indexify()
processed, found = yreplace(exprs, make,
make_is_time_invariant(exprs),
lambda i: estimate_cost(i) > 0)
assert len(found) == len(expected)
assert all(str(i.rhs) == j for i, j in zip(found, expected))
def _extract_sum_of_products(self, cluster, template, **kwargs):
"""
Extract sub-expressions in sum-of-product form, and assign them to temporaries.
"""
make = lambda: Scalar(name=template(), dtype=cluster.dtype).indexify()
rule = q_sum_of_product
costmodel = lambda e: not (q_leaf(e) or q_terminalop(e))
processed, _ = yreplace(cluster.exprs, make, rule, costmodel)
return cluster.rebuild(processed)
def _extract_time_invariants(self, cluster, template, **kwargs):
"""
Extract time-invariant subexpressions, and assign them to temporaries.
"""
make = lambda: Scalar(name=template(), dtype=cluster.dtype).indexify()
rule = make_is_time_invariant(cluster.exprs)
costmodel = lambda e: estimate_cost(e, True) >= self.MIN_COST_ALIAS_INV
processed, found = yreplace(cluster.exprs, make, rule, costmodel, eager=True)
return cluster.rebuild(processed)
def extract(cluster, rule1, model, template):
make = lambda: Scalar(name=template(), dtype=cluster.dtype).indexify()
# Rule out symbols inducing Dimension-independent data dependences
exclude = {i.source.indexed for i in cluster.scope.d_flow.independent()}
rule0 = lambda e: not e.free_symbols & exclude
# Composite extraction rule -- correctness(0) + logic(1)
rule = lambda e: rule0(e) and rule1(e)
return yreplace(cluster.exprs, make, rule, model, eager=True)
def test_yreplace_time_invariants(exprs, expected):
grid = Grid((3, 3, 3))
dims = grid.dimensions
tu = TimeFunction(name="tu", grid=grid, space_order=4).indexify()
tv = TimeFunction(name="tv", grid=grid, space_order=4).indexify()
tw = TimeFunction(name="tw", grid=grid, space_order=4).indexify()
ti0 = Array(name='ti0', shape=(3, 5, 7), dimensions=dims).indexify()
ti1 = Array(name='ti1', shape=(3, 5, 7), dimensions=dims).indexify()
t0 = Scalar(name='t0').indexify()
t1 = Scalar(name='t1').indexify()
exprs = EVAL(exprs, tu, tv, tw, ti0, ti1, t0, t1)
counter = generator()
make = lambda: Scalar(name='r%d' % counter()).indexify()
processed, found = yreplace(exprs, make, make_is_time_invariant(exprs),
lambda i: estimate_cost(i) > 0)
assert len(found) == len(expected)
assert all(str(i.rhs) == j for i, j in zip(found, expected))
def _compact_temporaries(exprs):
"""
Drop temporaries consisting of isolated symbols.
"""
# First of all, convert to SSA
exprs = makeit_ssa(exprs)
# What's gonna be dropped
mapper = {e.lhs: e.rhs for e in exprs
if e.lhs.is_Symbol and (q_leaf(e.rhs) or e.rhs.is_Function)}
processed = []
for e in exprs:
if e.lhs not in mapper:
# The temporary is retained, and substitutions may be applied
handle, _ = yreplace(e, mapper, repeat=True)
assert len(handle) == 1
processed.extend(handle)
return processed
