def extract(cls, n, context, min_cost, cluster, sregistry): make = lambda: Scalar(name=sregistry.make_name(), dtype=cluster.dtype ).indexify() exclude = { i.source.indexed for i in cluster.scope.d_flow.independent() } rule0 = lambda e: not e.free_symbols & exclude rule1 = make_is_time_invariant(context) rule2 = lambda e: estimate_cost(e, True) >= min_cost rule = lambda e: rule0(e) and rule1(e) and rule2(e) extracted = [] mapper = OrderedDict() for e in cluster.exprs: for i in search(e, rule, 'all', 'dfs_first_hit'): if i not in mapper: symbol = make() mapper[i] = symbol extracted.append(e.func(symbol, i)) processed = [uxreplace(e, mapper) for e in cluster.exprs] return extracted + processed, extracted
def _extract_rule(cls, context, min_cost, cluster): exclude = { i.source.indexed for i in cluster.scope.d_flow.independent() } rule0 = lambda e: not e.free_symbols & exclude rule1 = make_is_time_invariant(context) rule2 = lambda e: estimate_cost(e, True) >= min_cost return lambda e: rule0(e) and rule1(e) and rule2(e)
def callbacks_invariants(context, n): min_cost_inv = min_cost['invariants'] if callable(min_cost_inv): min_cost_inv = min_cost_inv(n) extractor = make_is_time_invariant(context) model = lambda e: estimate_cost(e, True) >= min_cost_inv ignore_collected = lambda g: False selector = lambda c, n: c >= min_cost_inv and n >= 1 return extractor, model, ignore_collected, selector
def extract_time_invariants(cluster, template, *args): """ 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) >= MIN_COST_ALIAS_INV processed, found = yreplace(cluster.exprs, make, rule, costmodel, eager=True) return cluster.rebuild(processed)
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 extract(exprs, aliases): """ Extract the candidate aliases. """ is_time_invariant = make_is_time_invariant(exprs) time_invariants = {e.rhs: is_time_invariant(e) for e in exprs} processed = [] candidates = OrderedDict() for e in exprs: # Cost check (to keep the memory footprint under control) naliases = len(aliases.get(e.rhs)) cost = estimate_cost(e, True) * naliases test0 = lambda: cost >= MIN_COST_ALIAS and naliases > 1 test1 = lambda: cost >= MIN_COST_ALIAS_INV and time_invariants[e.rhs] if test0() or test1(): candidates[e.rhs] = e.lhs else: processed.append(e) return candidates, processed
def callbacks_invariants(context, *args): extractor = make_is_time_invariant(context) model = lambda e: estimate_cost(e, True) >= MIN_COST_ALIAS_INV ignore_collected = lambda g: False selector = lambda c, n: c >= MIN_COST_ALIAS_INV and n >= 1 return extractor, model, ignore_collected, selector
def extractor(context): is_time_invariant = make_is_time_invariant(context) return lambda e: is_time_invariant(e)
def extractor(context): return make_is_time_invariant(context)