def _subset_has_indirection(subset):
for dim in subset:
if not isinstance(dim, tuple):
dim = [dim]
for r in dim:
if symbolic.contains_sympy_functions(r):
return True
return False
def _assignments_to_consider(sdfg, edge):
assignments_to_consider = {}
for var, assign in edge.data.assignments.items():
as_symbolic = symbolic.pystr_to_symbolic(assign)
# Assignments cannot access a data container
if not symbolic.contains_sympy_functions(as_symbolic): # via subscript
# Assignments cannot use scalar values
for sym in as_symbolic.free_symbols:
if str(sym) in sdfg.arrays:
break
else:
assignments_to_consider[var] = assign
return assignments_to_consider
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