def can_be_applied(graph, candidate, expr_index, sdfg, strict=False):
if not DetectLoop.can_be_applied(graph, candidate, expr_index, sdfg,
strict):
return False
guard = graph.node(candidate[DetectLoop._loop_guard])
begin = graph.node(candidate[DetectLoop._loop_begin])
# If loop cannot be detected, fail
found = find_for_loop(sdfg, guard, begin)
if found is None:
return False
return True
def can_be_applied(graph, candidate, expr_index, sdfg, strict=False):
if not DetectLoop.can_be_applied(graph, candidate, expr_index, sdfg,
strict):
return False
guard = graph.node(candidate[DetectLoop._loop_guard])
begin = graph.node(candidate[DetectLoop._loop_begin])
# Obtain iteration variable, range, and stride
guard_inedges = graph.in_edges(guard)
condition_edge = graph.edges_between(guard, begin)[0]
itervar = list(guard_inedges[0].data.assignments.keys())[0]
condition = condition_edge.data.condition_sympy()
# If loop cannot be detected, fail
rng = LoopUnroll._loop_range(itervar, guard_inedges, condition)
if not rng:
return False
return True
def can_be_applied(graph, candidate, expr_index, sdfg, strict=False):
# Is this even a loop
if not DetectLoop.can_be_applied(graph, candidate, expr_index, sdfg,
strict):
return False
guard = graph.node(candidate[DetectLoop._loop_guard])
begin = graph.node(candidate[DetectLoop._loop_begin])
found = find_for_loop(graph, guard, begin)
# If loop cannot be detected, fail
if not found:
return False
_, rng, _ = found
# If loop stride is not specialized or constant-sized, fail
if symbolic.issymbolic(rng[2], sdfg.constants):
return False
# If loop range diff is not constant-sized, fail
if symbolic.issymbolic(rng[1] - rng[0], sdfg.constants):
return False
return True
def can_be_applied(self, graph, candidate, expr_index, sdfg, strict=False):
# Is this even a loop
if not DetectLoop.can_be_applied(graph, candidate, expr_index, sdfg,
strict):
return False
guard = graph.node(candidate[DetectLoop._loop_guard])
begin = graph.node(candidate[DetectLoop._loop_begin])
# Guard state should not contain any dataflow
if len(guard.nodes()) != 0:
return False
# If loop cannot be detected, fail
found = find_for_loop(graph, guard, begin,
itervar=self.itervar)
if not found:
return False
itervar, (start, end, step), (_, body_end) = found
# We cannot handle symbols read from data containers unless they are
# scalar
for expr in (start, end, step):
if symbolic.contains_sympy_functions(expr):
return False
# Find all loop-body states
states = set([body_end])
to_visit = [begin]
while to_visit:
state = to_visit.pop(0)
if state is body_end:
continue
for _, dst, _ in graph.out_edges(state):
if dst not in states:
to_visit.append(dst)
states.add(state)
write_set = set()
for state in states:
_, wset = state.read_and_write_sets()
write_set |= wset
# Get access nodes from other states to isolate local loop variables
other_access_nodes = set()
for state in sdfg.nodes():
if state in states:
continue
other_access_nodes |= set(n.data for n in state.data_nodes()
if sdfg.arrays[n.data].transient)
# Add non-transient nodes from loop state
for state in states:
other_access_nodes |= set(n.data for n in state.data_nodes()
if not sdfg.arrays[n.data].transient)
write_memlets = defaultdict(list)
itersym = symbolic.pystr_to_symbolic(itervar)
a = sp.Wild('a', exclude=[itersym])
b = sp.Wild('b', exclude=[itersym])
for state in states:
for dn in state.data_nodes():
if dn.data not in other_access_nodes:
continue
# Take all writes that are not conflicted into consideration
if dn.data in write_set:
for e in state.in_edges(dn):
if e.data.dynamic and e.data.wcr is None:
# If pointers are involved, give up
return False
# To be sure that the value is only written at unique
# indices per loop iteration, we want to match symbols
# of the form "a*i+b" where a >= 1, and i is the iteration
# variable. The iteration variable must be used.
if e.data.wcr is None:
dst_subset = e.data.get_dst_subset(e, state)
if not _check_range(dst_subset, a, itersym, b, step):
return False
# End of check
write_memlets[dn.data].append(e.data)
# After looping over relevant writes, consider reads that may overlap
for state in states:
for dn in state.data_nodes():
if dn.data not in other_access_nodes:
continue
data = dn.data
if data in write_memlets:
# Import as necessary
from dace.sdfg.propagation import propagate_subset
for e in state.out_edges(dn):
# If the same container is both read and written, only match if
# it read and written at locations that will not create data races
if e.data.dynamic and e.data.src_subset.num_elements() != 1:
# If pointers are involved, give up
return False
src_subset = e.data.get_src_subset(e, state)
if not _check_range(src_subset, a, itersym, b, step):
return False
pread = propagate_subset([e.data], sdfg.arrays[data],
[itervar],
subsets.Range([(start, end, step)
]))
for candidate in write_memlets[data]:
# Simple case: read and write are in the same subset
if e.data.subset == candidate.subset:
break
# Propagated read does not overlap with propagated write
pwrite = propagate_subset([candidate],
sdfg.arrays[data], [itervar],
subsets.Range([(start, end,
step)]))
if subsets.intersects(pread.subset,
pwrite.subset) is False:
break
return False
# Check that the iteration variable is not used on other edges or states
# before it is reassigned
prior_states = True
for state in cfg.stateorder_topological_sort(sdfg):
# Skip all states up to guard
if prior_states:
if state is begin:
prior_states = False
continue
# We do not need to check the loop-body states
if state in states:
continue
if itervar in state.free_symbols:
return False
# Don't continue in this direction, as the variable has
# now been reassigned
# TODO: Handle case of subset of out_edges
if all(itervar in e.data.assignments
for e in sdfg.out_edges(state)):
break
return True
def can_be_applied(graph, candidate, expr_index, sdfg, strict=False):
if not DetectLoop.can_be_applied(graph, candidate, expr_index, sdfg,
strict):
return False
return True