def can_be_applied(graph, candidate, expr_index, sdfg, strict=False):
in_array = graph.nodes()[candidate[RedundantSecondArray._in_array]]
out_array = graph.nodes()[candidate[RedundantSecondArray._out_array]]
in_desc = in_array.desc(sdfg)
out_desc = out_array.desc(sdfg)
# Ensure in degree is one (only one source, which is in_array)
if graph.in_degree(out_array) != 1:
return False
# Make sure that the candidate is a transient variable
if not out_desc.transient:
return False
# Dimensionality must be the same in strict mode
if strict and len(in_desc.shape) != len(out_desc.shape):
return False
# Make sure that both arrays are using the same storage location
# and are of the same type (e.g., Stream->Stream)
if in_desc.storage != out_desc.storage:
return False
if type(in_desc) != type(out_desc):
return False
# Find occurrences in this and other states
occurrences = []
for state in sdfg.nodes():
occurrences.extend([
n for n in state.nodes()
if isinstance(n, nodes.AccessNode) and n.desc(sdfg) == out_desc
])
for isedge in sdfg.edges():
if out_array.data in isedge.data.free_symbols:
occurrences.append(isedge)
if len(occurrences) > 1:
return False
# Check whether the data copied from the first datanode cover
# the subsets of all the output edges of the second datanode.
# We assume the following pattern: A -- e1 --> B -- e2 --> others
# 1. Get edge e1 and extract/validate subsets for arrays A and B
e1 = graph.edges_between(in_array, out_array)[0]
try:
_, b1_subset = _validate_subsets(e1, sdfg.arrays)
except NotImplementedError:
return False
# 2. Iterate over the e2 edges
for e2 in graph.out_edges(out_array):
# 2-a. Extract/validate subsets for array B and others
try:
b2_subset, _ = _validate_subsets(e2, sdfg.arrays)
except NotImplementedError:
return False
# 2-b. Check where b1_subset covers b2_subset
if not b1_subset.covers(b2_subset):
return False
# 2-c. Validate subsets in memlet tree
# (should not be needed for valid SDGs)
path = graph.memlet_tree(e2)
for e3 in path:
if e3 is not e2:
try:
_validate_subsets(e3,
sdfg.arrays,
src_name=out_array.data)
except NotImplementedError:
return False
return True
def can_be_applied(graph, candidate, expr_index, sdfg, strict=False):
in_array = graph.nodes()[candidate[RedundantSecondArray._in_array]]
out_array = graph.nodes()[candidate[RedundantSecondArray._out_array]]
in_desc = in_array.desc(sdfg)
out_desc = out_array.desc(sdfg)
# Ensure in degree is one (only one source, which is in_array)
if graph.in_degree(out_array) != 1:
return False
# Make sure that the candidate is a transient variable
if not out_desc.transient:
return False
# 1. Get edge e1 and extract/validate subsets for arrays A and B
e1 = graph.edges_between(in_array, out_array)[0]
a_subset, b1_subset = _validate_subsets(e1, sdfg.arrays)
if strict:
# In strict mode, make sure the memlet covers the removed array
if not b1_subset:
return False
subset = copy.deepcopy(b1_subset)
subset.squeeze()
shape = [sz for sz in out_desc.shape if sz != 1]
if any(m != a for m, a in zip(subset.size(), shape)):
return False
# NOTE: Library node check
# The transformation must not apply in strict mode if out_array is
# not a view, is input to a library node, and an access or a view
# of in_desc is also output to the same library node.
# The reason is that the application of the transformation will lead
# to in_desc being both input and output of the library node.
# We do not know if this is safe.
# First find the true in_desc (in case in_array is a view).
true_in_desc = in_desc
if isinstance(in_desc, data.View):
e = sdutil.get_view_edge(graph, in_array)
if not e:
return False
true_in_desc = sdfg.arrays[e.dst.data]
if not isinstance(out_desc, data.View):
edges_to_check = []
for a in graph.out_edges(out_array):
if isinstance(a.dst, nodes.LibraryNode):
edges_to_check.append(a)
elif (isinstance(a.dst, nodes.AccessNode)
and isinstance(sdfg.arrays[a.dst.data], data.View)):
for b in graph.out_edges(a.dst):
edges_to_check.append(graph.memlet_path(b)[-1])
for a in edges_to_check:
if isinstance(a.dst, nodes.LibraryNode):
for b in graph.out_edges(a.dst):
if isinstance(b.dst, nodes.AccessNode):
desc = sdfg.arrays[b.dst.data]
if isinstance(desc, data.View):
e = sdutil.get_view_edge(graph, b.dst)
if not e:
return False
desc = sdfg.arrays[e.dst.data]
if desc is true_in_desc:
return False
# In strict mode, check if the state has two or more access nodes
# for in_array and at least one of them is a write access. There
# might be a RW, WR, or WW dependency.
accesses = [
n for n in graph.nodes() if isinstance(n, nodes.AccessNode)
and n.desc(sdfg) == in_desc and n is not in_array
]
if len(accesses) > 0:
if (graph.in_degree(in_array) > 0
or any(graph.in_degree(a) > 0 for a in accesses)):
# We need to ensure that a data race will not happen if we
# remove in_array.
# First, we simplify the graph
G = helpers.simplify_state(graph)
# Loop over the accesses
for a in accesses:
subsets_intersect = False
for e in graph.in_edges(a):
_, subset = _validate_subsets(e,
sdfg.arrays,
dst_name=a.data)
res = subsets.intersects(a_subset, subset)
if res == True or res is None:
subsets_intersect = True
break
if not subsets_intersect:
continue
try:
has_bward_path = nx.has_path(G, a, in_array)
except NodeNotFound:
has_bward_path = nx.has_path(graph.nx, a, in_array)
try:
has_fward_path = nx.has_path(G, in_array, a)
except NodeNotFound:
has_fward_path = nx.has_path(graph.nx, in_array, a)
# If there is no path between the access nodes
# (disconnected components), then it is definitely
# possible to have data races. Abort.
if not (has_bward_path or has_fward_path):
return False
# If there is a forward path then a must not be a direct
# successor of in_array.
if has_fward_path and a in G.successors(in_array):
for src, _ in G.in_edges(a):
if src is in_array:
continue
if (nx.has_path(G, in_array, src)
and src != out_array):
continue
return False
# Make sure that both arrays are using the same storage location
# and are of the same type (e.g., Stream->Stream)
if in_desc.storage != out_desc.storage:
return False
if in_desc.location != out_desc.location:
return False
if type(in_desc) != type(out_desc):
if isinstance(in_desc, data.View):
# Case View -> Access
# If the View points to the Access (and has a different shape?)
# then we should (probably) not remove the Access.
e = sdutil.get_view_edge(graph, in_array)
if e and e.dst is out_array and in_desc.shape != out_desc.shape:
return False
# Check that the View's immediate ancestors are Accesses.
# Otherwise, the application of the transformation will result
# in an ambiguous View.
view_ancestors_desc = [
e.src.desc(sdfg)
if isinstance(e.src, nodes.AccessNode) else None
for e in graph.in_edges(in_array)
]
if any([
not desc or isinstance(desc, data.View)
for desc in view_ancestors_desc
]):
return False
elif isinstance(out_desc, data.View):
# Case Access -> View
# If the View points to the Access and has the same shape,
# it can be removed
e = sdutil.get_view_edge(graph, out_array)
if e and e.src is in_array and in_desc.shape == out_desc.shape:
return True
return False
else:
# Something else, for example, Stream
return False
else:
# Two views connected to each other
if isinstance(in_desc, data.View):
return False
# Find occurrences in this and other states
occurrences = []
for state in sdfg.nodes():
occurrences.extend([
n for n in state.nodes()
if isinstance(n, nodes.AccessNode) and n.desc(sdfg) == out_desc
])
for isedge in sdfg.edges():
if out_array.data in isedge.data.free_symbols:
occurrences.append(isedge)
if len(occurrences) > 1:
return False
# Check whether the data copied from the first datanode cover
# the subsets of all the output edges of the second datanode.
# We assume the following pattern: A -- e1 --> B -- e2 --> others
# 2. Iterate over the e2 edges
for e2 in graph.out_edges(out_array):
# 2-a. Extract/validate subsets for array B and others
try:
b2_subset, _ = _validate_subsets(e2, sdfg.arrays)
except NotImplementedError:
return False
# 2-b. Check where b1_subset covers b2_subset
if not b1_subset.covers(b2_subset):
return False
# 2-c. Validate subsets in memlet tree
# (should not be needed for valid SDGs)
path = graph.memlet_tree(e2)
for e3 in path:
if e3 is not e2:
try:
_validate_subsets(e3,
sdfg.arrays,
src_name=out_array.data)
except NotImplementedError:
return False
return True