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