def __init__(self,
label,
inputs=None,
outputs=None,
code="",
language=dtypes.Language.Python,
location=None,
debuginfo=None):
super(Tasklet, self).__init__(label, location, inputs, outputs)
self.code = CodeBlock(code, language)
self.debuginfo = debuginfo
def __init__(self,
label,
inputs=None,
outputs=None,
code="",
language=dtypes.Language.Python,
state_fields=None,
code_global="",
code_init="",
code_exit="",
location=None,
debuginfo=None):
super(Tasklet, self).__init__(label, location, inputs, outputs)
self.code = CodeBlock(code, language)
self.state_fields = state_fields or []
self.code_global = CodeBlock(code_global, dtypes.Language.CPP)
self.code_init = CodeBlock(code_init, dtypes.Language.CPP)
self.code_exit = CodeBlock(code_exit, dtypes.Language.CPP)
self.debuginfo = debuginfo
def apply(self, _, sdfg: sd.SDFG):
# Obtain loop information
guard: sd.SDFGState = self.loop_guard
body: sd.SDFGState = self.loop_begin
# Obtain iteration variable, range and stride
itervar, (start, end,
step), (_, body_end) = find_for_loop(sdfg, guard, body)
# Find all loop-body states
states = set()
to_visit = [body]
while to_visit:
state = to_visit.pop(0)
for _, dst, _ in sdfg.out_edges(state):
if dst not in states and dst is not guard:
to_visit.append(dst)
states.add(state)
for state in states:
state.replace(itervar, start)
# remove loop
for body_inedge in sdfg.in_edges(body):
sdfg.remove_edge(body_inedge)
for body_outedge in sdfg.out_edges(body_end):
sdfg.remove_edge(body_outedge)
for guard_inedge in sdfg.in_edges(guard):
guard_inedge.data.assignments = {}
sdfg.add_edge(guard_inedge.src, body, guard_inedge.data)
sdfg.remove_edge(guard_inedge)
for guard_outedge in sdfg.out_edges(guard):
guard_outedge.data.condition = CodeBlock("1")
sdfg.add_edge(body_end, guard_outedge.dst, guard_outedge.data)
sdfg.remove_edge(guard_outedge)
sdfg.remove_node(guard)
if itervar in sdfg.symbols and helpers.is_symbol_unused(sdfg, itervar):
sdfg.remove_symbol(itervar)
class Tasklet(CodeNode):
""" A node that contains a tasklet: a functional computation procedure
that can only access external data specified using connectors.
Tasklets may be implemented in Python, C++, or any supported
language by the code generator.
"""
code = CodeProperty(desc="Tasklet code", default=CodeBlock(""))
debuginfo = DebugInfoProperty()
instrument = Property(choices=dtypes.InstrumentationType,
desc="Measure execution statistics with given method",
default=dtypes.InstrumentationType.No_Instrumentation)
def __init__(self,
label,
inputs=None,
outputs=None,
code="",
language=dtypes.Language.Python,
location=None,
debuginfo=None):
super(Tasklet, self).__init__(label, location, inputs, outputs)
self.code = CodeBlock(code, language)
self.debuginfo = debuginfo
@property
def language(self):
return self.code.language
@staticmethod
def from_json(json_obj, context=None):
ret = Tasklet("dummylabel")
dace.serialize.set_properties_from_json(ret, json_obj, context=context)
return ret
@property
def name(self):
return self._label
def validate(self, sdfg, state):
if not dtypes.validate_name(self.label):
raise NameError('Invalid tasklet name "%s"' % self.label)
for in_conn in self.in_connectors:
if not dtypes.validate_name(in_conn):
raise NameError('Invalid input connector "%s"' % in_conn)
for out_conn in self.out_connectors:
if not dtypes.validate_name(out_conn):
raise NameError('Invalid output connector "%s"' % out_conn)
@property
def free_symbols(self) -> Set[str]:
return self.code.get_free_symbols(self.in_connectors.keys()
| self.out_connectors.keys())
def infer_connector_types(self, sdfg, state):
# If a Python tasklet, use type inference to figure out all None output
# connectors
if all(cval.type is not None for cval in self.out_connectors.values()):
return
if self.code.language != dtypes.Language.Python:
return
if any(cval.type is None for cval in self.in_connectors.values()):
raise TypeError('Cannot infer output connectors of tasklet "%s", '
'not all input connectors have types' % str(self))
# Avoid import loop
from dace.codegen.tools.type_inference import infer_types
# Get symbols defined at beginning of node, and infer all types in
# tasklet
syms = state.symbols_defined_at(self)
syms.update(self.in_connectors)
new_syms = infer_types(self.code.code, syms)
for cname, oconn in self.out_connectors.items():
if oconn.type is None:
if cname not in new_syms:
raise TypeError('Cannot infer type of tasklet %s output '
'"%s", please specify manually.' %
(self.label, cname))
self.out_connectors[cname] = new_syms[cname]
def __str__(self):
if not self.label:
return "--Empty--"
else:
return self.label
class Tasklet(CodeNode):
""" A node that contains a tasklet: a functional computation procedure
that can only access external data specified using connectors.
Tasklets may be implemented in Python, C++, or any supported
language by the code generator.
"""
code = CodeProperty(desc="Tasklet code", default=CodeBlock(""))
debuginfo = DebugInfoProperty()
instrument = Property(
choices=dtypes.InstrumentationType,
desc="Measure execution statistics with given method",
default=dtypes.InstrumentationType.No_Instrumentation)
def __init__(self,
label,
inputs=None,
outputs=None,
code="",
language=dtypes.Language.Python,
location=None,
debuginfo=None):
super(Tasklet, self).__init__(label, location, inputs, outputs)
self.code = CodeBlock(code, language)
self.debuginfo = debuginfo
@property
def language(self):
return self.code.language
@staticmethod
def from_json(json_obj, context=None):
ret = Tasklet("dummylabel")
dace.serialize.set_properties_from_json(ret, json_obj, context=context)
return ret
@property
def name(self):
return self._label
def validate(self, sdfg, state):
if not dtypes.validate_name(self.label):
raise NameError('Invalid tasklet name "%s"' % self.label)
for in_conn in self.in_connectors:
if not dtypes.validate_name(in_conn):
raise NameError('Invalid input connector "%s"' % in_conn)
for out_conn in self.out_connectors:
if not dtypes.validate_name(out_conn):
raise NameError('Invalid output connector "%s"' % out_conn)
@property
def free_symbols(self) -> Set[str]:
return self.code.get_free_symbols(self.in_connectors
| self.out_connectors)
def __str__(self):
if not self.label:
return "--Empty--"
else:
return self.label
def apply(self, _, sdfg: sd.SDFG):
# Obtain loop information
guard: sd.SDFGState = self.loop_guard
body: sd.SDFGState = self.loop_begin
# Obtain iteration variable, range, and stride
itervar, (start, end, step), _ = find_for_loop(sdfg, guard, body)
forward_loop = step > 0
for node in body.nodes():
if isinstance(node, nodes.MapEntry):
map_entry = node
if isinstance(node, nodes.MapExit):
map_exit = node
# nest map's content in sdfg
map_subgraph = body.scope_subgraph(map_entry, include_entry=False, include_exit=False)
nsdfg = helpers.nest_state_subgraph(sdfg, body, map_subgraph, full_data=True)
# replicate loop in nested sdfg
new_before, new_guard, new_after = nsdfg.sdfg.add_loop(
before_state=None,
loop_state=nsdfg.sdfg.nodes()[0],
loop_end_state=None,
after_state=None,
loop_var=itervar,
initialize_expr=f'{start}',
condition_expr=f'{itervar} <= {end}' if forward_loop else f'{itervar} >= {end}',
increment_expr=f'{itervar} + {step}' if forward_loop else f'{itervar} - {abs(step)}')
# remove outer loop
before_guard_edge = nsdfg.sdfg.edges_between(new_before, new_guard)[0]
for e in nsdfg.sdfg.out_edges(new_guard):
if e.dst is new_after:
guard_after_edge = e
else:
guard_body_edge = e
for body_inedge in sdfg.in_edges(body):
if body_inedge.src is guard:
guard_body_edge.data.assignments.update(body_inedge.data.assignments)
sdfg.remove_edge(body_inedge)
for body_outedge in sdfg.out_edges(body):
sdfg.remove_edge(body_outedge)
for guard_inedge in sdfg.in_edges(guard):
before_guard_edge.data.assignments.update(guard_inedge.data.assignments)
guard_inedge.data.assignments = {}
sdfg.add_edge(guard_inedge.src, body, guard_inedge.data)
sdfg.remove_edge(guard_inedge)
for guard_outedge in sdfg.out_edges(guard):
if guard_outedge.dst is body:
guard_body_edge.data.assignments.update(guard_outedge.data.assignments)
else:
guard_after_edge.data.assignments.update(guard_outedge.data.assignments)
guard_outedge.data.condition = CodeBlock("1")
sdfg.add_edge(body, guard_outedge.dst, guard_outedge.data)
sdfg.remove_edge(guard_outedge)
sdfg.remove_node(guard)
if itervar in nsdfg.symbol_mapping:
del nsdfg.symbol_mapping[itervar]
if itervar in sdfg.symbols:
del sdfg.symbols[itervar]
# Add missing data/symbols
for s in nsdfg.sdfg.free_symbols:
if s in nsdfg.symbol_mapping:
continue
if s in sdfg.symbols:
nsdfg.symbol_mapping[s] = s
elif s in sdfg.arrays:
desc = sdfg.arrays[s]
access = body.add_access(s)
conn = nsdfg.sdfg.add_datadesc(s, copy.deepcopy(desc))
nsdfg.sdfg.arrays[s].transient = False
nsdfg.add_in_connector(conn)
body.add_memlet_path(access, map_entry, nsdfg, memlet=Memlet.from_array(s, desc), dst_conn=conn)
else:
raise NotImplementedError(f"Free symbol {s} is neither a symbol nor data.")
to_delete = set()
for s in nsdfg.symbol_mapping:
if s not in nsdfg.sdfg.free_symbols:
to_delete.add(s)
for s in to_delete:
del nsdfg.symbol_mapping[s]
# propagate scope for correct volumes
scope_tree = ScopeTree(map_entry, map_exit)
scope_tree.parent = ScopeTree(None, None)
# The first execution helps remove apperances of symbols
# that are now defined only in the nested SDFG in memlets.
propagation.propagate_memlets_scope(sdfg, body, scope_tree)
for s in to_delete:
if helpers.is_symbol_unused(sdfg, s):
sdfg.remove_symbol(s)
from dace.transformation.interstate import RefineNestedAccess
transformation = RefineNestedAccess()
transformation.setup_match(sdfg, 0, sdfg.node_id(body), {RefineNestedAccess.nsdfg: body.node_id(nsdfg)}, 0)
transformation.apply(body, sdfg)
# Second propagation for refined accesses.
propagation.propagate_memlets_scope(sdfg, body, scope_tree)
def apply(self, sdfg: sd.SDFG):
# Obtain loop information
guard: sd.SDFGState = sdfg.node(self.subgraph[DetectLoop._loop_guard])
body: sd.SDFGState = sdfg.node(self.subgraph[DetectLoop._loop_begin])
after: sd.SDFGState = sdfg.node(self.subgraph[DetectLoop._exit_state])
# Obtain iteration variable, range, and stride
itervar, (start, end, step), (_, body_end) = find_for_loop(
sdfg, guard, body, itervar=self.itervar)
# Find all loop-body states
states = set([body_end])
to_visit = [body]
while to_visit:
state = to_visit.pop(0)
if state is body_end:
continue
for _, dst, _ in sdfg.out_edges(state):
if dst not in states:
to_visit.append(dst)
states.add(state)
# Nest loop-body states
if len(states) > 1:
# Find read/write sets
read_set, write_set = set(), set()
for state in states:
rset, wset = state.read_and_write_sets()
read_set |= rset
write_set |= wset
# Add data from edges
for src in states:
for dst in states:
for edge in sdfg.edges_between(src, dst):
for s in edge.data.free_symbols:
if s in sdfg.arrays:
read_set.add(s)
# Find NestedSDFG's unique data
rw_set = read_set | write_set
unique_set = set()
for name in rw_set:
if not sdfg.arrays[name].transient:
continue
found = False
for state in sdfg.states():
if state in states:
continue
for node in state.nodes():
if (isinstance(node, nodes.AccessNode) and
node.data == name):
found = True
break
if not found:
unique_set.add(name)
# Find NestedSDFG's connectors
read_set = {n for n in read_set if n not in unique_set or not sdfg.arrays[n].transient}
write_set = {n for n in write_set if n not in unique_set or not sdfg.arrays[n].transient}
# Create NestedSDFG and add all loop-body states and edges
# Also, find defined symbols in NestedSDFG
fsymbols = set(sdfg.free_symbols)
new_body = sdfg.add_state('single_state_body')
nsdfg = SDFG("loop_body", constants=sdfg.constants, parent=new_body)
nsdfg.add_node(body, is_start_state=True)
body.parent = nsdfg
exit_state = nsdfg.add_state('exit')
nsymbols = dict()
for state in states:
if state is body:
continue
nsdfg.add_node(state)
state.parent = nsdfg
for state in states:
if state is body:
continue
for src, dst, data in sdfg.in_edges(state):
nsymbols.update({s: sdfg.symbols[s] for s in data.assignments.keys() if s in sdfg.symbols})
nsdfg.add_edge(src, dst, data)
nsdfg.add_edge(body_end, exit_state, InterstateEdge())
# Move guard -> body edge to guard -> new_body
for src, dst, data, in sdfg.edges_between(guard, body):
sdfg.add_edge(src, new_body, data)
# Move body_end -> guard edge to new_body -> guard
for src, dst, data in sdfg.edges_between(body_end, guard):
sdfg.add_edge(new_body, dst, data)
# Delete loop-body states and edges from parent SDFG
for state in states:
for e in sdfg.all_edges(state):
sdfg.remove_edge(e)
sdfg.remove_node(state)
# Add NestedSDFG arrays
for name in read_set | write_set:
nsdfg.arrays[name] = copy.deepcopy(sdfg.arrays[name])
nsdfg.arrays[name].transient = False
for name in unique_set:
nsdfg.arrays[name] = sdfg.arrays[name]
del sdfg.arrays[name]
# Add NestedSDFG node
cnode = new_body.add_nested_sdfg(nsdfg, None, read_set, write_set)
if sdfg.parent:
for s, m in sdfg.parent_nsdfg_node.symbol_mapping.items():
if s not in cnode.symbol_mapping:
cnode.symbol_mapping[s] = m
nsdfg.add_symbol(s, sdfg.symbols[s])
for name in read_set:
r = new_body.add_read(name)
new_body.add_edge(
r, None, cnode, name,
memlet.Memlet.from_array(name, sdfg.arrays[name]))
for name in write_set:
w = new_body.add_write(name)
new_body.add_edge(
cnode, name, w, None,
memlet.Memlet.from_array(name, sdfg.arrays[name]))
# Fix SDFG symbols
for sym in sdfg.free_symbols - fsymbols:
del sdfg.symbols[sym]
for sym, dtype in nsymbols.items():
nsdfg.symbols[sym] = dtype
# Change body state reference
body = new_body
if (step < 0) == True:
# If step is negative, we have to flip start and end to produce a
# correct map with a positive increment
start, end, step = end, start, -step
# If necessary, make a nested SDFG with assignments
isedge = sdfg.edges_between(guard, body)[0]
symbols_to_remove = set()
if len(isedge.data.assignments) > 0:
nsdfg = helpers.nest_state_subgraph(
sdfg, body, gr.SubgraphView(body, body.nodes()))
for sym in isedge.data.free_symbols:
if sym in nsdfg.symbol_mapping or sym in nsdfg.in_connectors:
continue
if sym in sdfg.symbols:
nsdfg.symbol_mapping[sym] = symbolic.pystr_to_symbolic(sym)
nsdfg.sdfg.add_symbol(sym, sdfg.symbols[sym])
elif sym in sdfg.arrays:
if sym in nsdfg.sdfg.arrays:
raise NotImplementedError
rnode = body.add_read(sym)
nsdfg.add_in_connector(sym)
desc = copy.deepcopy(sdfg.arrays[sym])
desc.transient = False
nsdfg.sdfg.add_datadesc(sym, desc)
body.add_edge(rnode, None, nsdfg, sym, memlet.Memlet(sym))
nstate = nsdfg.sdfg.node(0)
init_state = nsdfg.sdfg.add_state_before(nstate)
nisedge = nsdfg.sdfg.edges_between(init_state, nstate)[0]
nisedge.data.assignments = isedge.data.assignments
symbols_to_remove = set(nisedge.data.assignments.keys())
for k in nisedge.data.assignments.keys():
if k in nsdfg.symbol_mapping:
del nsdfg.symbol_mapping[k]
isedge.data.assignments = {}
source_nodes = body.source_nodes()
sink_nodes = body.sink_nodes()
map = nodes.Map(body.label + "_map", [itervar], [(start, end, step)])
entry = nodes.MapEntry(map)
exit = nodes.MapExit(map)
body.add_node(entry)
body.add_node(exit)
# If the map uses symbols from data containers, instantiate reads
containers_to_read = entry.free_symbols & sdfg.arrays.keys()
for rd in containers_to_read:
# We are guaranteed that this is always a scalar, because
# can_be_applied makes sure there are no sympy functions in each of
# the loop expresions
access_node = body.add_read(rd)
body.add_memlet_path(access_node,
entry,
dst_conn=rd,
memlet=memlet.Memlet(rd))
# Reroute all memlets through the entry and exit nodes
for n in source_nodes:
if isinstance(n, nodes.AccessNode):
for e in body.out_edges(n):
body.remove_edge(e)
body.add_edge_pair(entry,
e.dst,
n,
e.data,
internal_connector=e.dst_conn)
else:
body.add_nedge(entry, n, memlet.Memlet())
for n in sink_nodes:
if isinstance(n, nodes.AccessNode):
for e in body.in_edges(n):
body.remove_edge(e)
body.add_edge_pair(exit,
e.src,
n,
e.data,
internal_connector=e.src_conn)
else:
body.add_nedge(n, exit, memlet.Memlet())
# Get rid of the loop exit condition edge
after_edge = sdfg.edges_between(guard, after)[0]
sdfg.remove_edge(after_edge)
# Remove the assignment on the edge to the guard
for e in sdfg.in_edges(guard):
if itervar in e.data.assignments:
del e.data.assignments[itervar]
# Remove the condition on the entry edge
condition_edge = sdfg.edges_between(guard, body)[0]
condition_edge.data.condition = CodeBlock("1")
# Get rid of backedge to guard
sdfg.remove_edge(sdfg.edges_between(body, guard)[0])
# Route body directly to after state, maintaining any other assignments
# it might have had
sdfg.add_edge(
body, after,
sd.InterstateEdge(assignments=after_edge.data.assignments))
# If this had made the iteration variable a free symbol, we can remove
# it from the SDFG symbols
if itervar in sdfg.free_symbols:
sdfg.remove_symbol(itervar)
for sym in symbols_to_remove:
if helpers.is_symbol_unused(sdfg, sym):
sdfg.remove_symbol(sym)
class Tasklet(CodeNode):
""" A node that contains a tasklet: a functional computation procedure
that can only access external data specified using connectors.
Tasklets may be implemented in Python, C++, or any supported
language by the code generator.
"""
code = CodeProperty(desc="Tasklet code", default=CodeBlock(""))
state_fields = ListProperty(
element_type=str, desc="Fields that are added to the global state")
code_global = CodeProperty(
desc="Global scope code needed for tasklet execution",
default=CodeBlock("", dtypes.Language.CPP))
code_init = CodeProperty(
desc="Extra code that is called on DaCe runtime initialization",
default=CodeBlock("", dtypes.Language.CPP))
code_exit = CodeProperty(
desc="Extra code that is called on DaCe runtime cleanup",
default=CodeBlock("", dtypes.Language.CPP))
debuginfo = DebugInfoProperty()
instrument = EnumProperty(
dtype=dtypes.InstrumentationType,
desc="Measure execution statistics with given method",
default=dtypes.InstrumentationType.No_Instrumentation)
def __init__(self,
label,
inputs=None,
outputs=None,
code="",
language=dtypes.Language.Python,
state_fields=None,
code_global="",
code_init="",
code_exit="",
location=None,
debuginfo=None):
super(Tasklet, self).__init__(label, location, inputs, outputs)
self.code = CodeBlock(code, language)
self.state_fields = state_fields or []
self.code_global = CodeBlock(code_global, dtypes.Language.CPP)
self.code_init = CodeBlock(code_init, dtypes.Language.CPP)
self.code_exit = CodeBlock(code_exit, dtypes.Language.CPP)
self.debuginfo = debuginfo
@property
def language(self):
return self.code.language
@staticmethod
def from_json(json_obj, context=None):
ret = Tasklet("dummylabel")
dace.serialize.set_properties_from_json(ret, json_obj, context=context)
return ret
@property
def name(self):
return self._label
def validate(self, sdfg, state):
if not dtypes.validate_name(self.label):
raise NameError('Invalid tasklet name "%s"' % self.label)
for in_conn in self.in_connectors:
if not dtypes.validate_name(in_conn):
raise NameError('Invalid input connector "%s"' % in_conn)
for out_conn in self.out_connectors:
if not dtypes.validate_name(out_conn):
raise NameError('Invalid output connector "%s"' % out_conn)
@property
def free_symbols(self) -> Set[str]:
return self.code.get_free_symbols(self.in_connectors.keys()
| self.out_connectors.keys())
def infer_connector_types(self, sdfg, state):
# If a MLIR tasklet, simply read out the types (it's explicit)
if self.code.language == dtypes.Language.MLIR:
# Inline import because mlir.utils depends on pyMLIR which may not be installed
# Doesn't cause crashes due to missing pyMLIR if a MLIR tasklet is not present
from dace.codegen.targets.mlir import utils
mlir_ast = utils.get_ast(self.code.code)
mlir_is_generic = utils.is_generic(mlir_ast)
mlir_entry_func = utils.get_entry_func(mlir_ast, mlir_is_generic)
mlir_result_type = utils.get_entry_result_type(
mlir_entry_func, mlir_is_generic)
mlir_out_name = next(iter(self.out_connectors.keys()))
if self.out_connectors[
mlir_out_name] is None or self.out_connectors[
mlir_out_name].ctype == "void":
self.out_connectors[mlir_out_name] = utils.get_dace_type(
mlir_result_type)
elif self.out_connectors[mlir_out_name] != utils.get_dace_type(
mlir_result_type):
warnings.warn(
"Type mismatch between MLIR tasklet out connector and MLIR code"
)
for mlir_arg in utils.get_entry_args(mlir_entry_func,
mlir_is_generic):
if self.in_connectors[
mlir_arg[0]] is None or self.in_connectors[
mlir_arg[0]].ctype == "void":
self.in_connectors[mlir_arg[0]] = utils.get_dace_type(
mlir_arg[1])
elif self.in_connectors[mlir_arg[0]] != utils.get_dace_type(
mlir_arg[1]):
warnings.warn(
"Type mismatch between MLIR tasklet in connector and MLIR code"
)
return
# If a Python tasklet, use type inference to figure out all None output
# connectors
if all(cval.type is not None for cval in self.out_connectors.values()):
return
if self.code.language != dtypes.Language.Python:
return
if any(cval.type is None for cval in self.in_connectors.values()):
raise TypeError('Cannot infer output connectors of tasklet "%s", '
'not all input connectors have types' % str(self))
# Avoid import loop
from dace.codegen.tools.type_inference import infer_types
# Get symbols defined at beginning of node, and infer all types in
# tasklet
syms = state.symbols_defined_at(self)
syms.update(self.in_connectors)
new_syms = infer_types(self.code.code, syms)
for cname, oconn in self.out_connectors.items():
if oconn.type is None:
if cname not in new_syms:
raise TypeError('Cannot infer type of tasklet %s output '
'"%s", please specify manually.' %
(self.label, cname))
self.out_connectors[cname] = new_syms[cname]
def __str__(self):
if not self.label:
return "--Empty--"
else:
return self.label
def apply(self, sdfg: sd.SDFG):
# Obtain loop information
guard: sd.SDFGState = sdfg.node(self.subgraph[DetectLoop._loop_guard])
body: sd.SDFGState = sdfg.node(self.subgraph[DetectLoop._loop_begin])
after: sd.SDFGState = sdfg.node(self.subgraph[DetectLoop._exit_state])
# Obtain iteration variable, range, and stride
itervar, (start, end, step), _ = find_for_loop(sdfg, guard, body)
if (step < 0) == True:
# If step is negative, we have to flip start and end to produce a
# correct map with a positive increment
start, end, step = end, start, -step
# If necessary, make a nested SDFG with assignments
isedge = sdfg.edges_between(guard, body)[0]
symbols_to_remove = set()
if len(isedge.data.assignments) > 0:
nsdfg = helpers.nest_state_subgraph(
sdfg, body, gr.SubgraphView(body, body.nodes()))
for sym in isedge.data.free_symbols:
if sym in nsdfg.symbol_mapping or sym in nsdfg.in_connectors:
continue
if sym in sdfg.symbols:
nsdfg.symbol_mapping[sym] = symbolic.pystr_to_symbolic(sym)
nsdfg.sdfg.add_symbol(sym, sdfg.symbols[sym])
elif sym in sdfg.arrays:
if sym in nsdfg.sdfg.arrays:
raise NotImplementedError
rnode = body.add_read(sym)
nsdfg.add_in_connector(sym)
desc = copy.deepcopy(sdfg.arrays[sym])
desc.transient = False
nsdfg.sdfg.add_datadesc(sym, desc)
body.add_edge(rnode, None, nsdfg, sym, memlet.Memlet(sym))
nstate = nsdfg.sdfg.node(0)
init_state = nsdfg.sdfg.add_state_before(nstate)
nisedge = nsdfg.sdfg.edges_between(init_state, nstate)[0]
nisedge.data.assignments = isedge.data.assignments
symbols_to_remove = set(nisedge.data.assignments.keys())
for k in nisedge.data.assignments.keys():
if k in nsdfg.symbol_mapping:
del nsdfg.symbol_mapping[k]
isedge.data.assignments = {}
source_nodes = body.source_nodes()
sink_nodes = body.sink_nodes()
map = nodes.Map(body.label + "_map", [itervar], [(start, end, step)])
entry = nodes.MapEntry(map)
exit = nodes.MapExit(map)
body.add_node(entry)
body.add_node(exit)
# If the map uses symbols from data containers, instantiate reads
containers_to_read = entry.free_symbols & sdfg.arrays.keys()
for rd in containers_to_read:
# We are guaranteed that this is always a scalar, because
# can_be_applied makes sure there are no sympy functions in each of
# the loop expresions
access_node = body.add_read(rd)
body.add_memlet_path(access_node,
entry,
dst_conn=rd,
memlet=memlet.Memlet(rd))
# Reroute all memlets through the entry and exit nodes
for n in source_nodes:
if isinstance(n, nodes.AccessNode):
for e in body.out_edges(n):
body.remove_edge(e)
body.add_edge_pair(entry,
e.dst,
n,
e.data,
internal_connector=e.dst_conn)
else:
body.add_nedge(entry, n, memlet.Memlet())
for n in sink_nodes:
if isinstance(n, nodes.AccessNode):
for e in body.in_edges(n):
body.remove_edge(e)
body.add_edge_pair(exit,
e.src,
n,
e.data,
internal_connector=e.src_conn)
else:
body.add_nedge(n, exit, memlet.Memlet())
# Get rid of the loop exit condition edge
after_edge = sdfg.edges_between(guard, after)[0]
sdfg.remove_edge(after_edge)
# Remove the assignment on the edge to the guard
for e in sdfg.in_edges(guard):
if itervar in e.data.assignments:
del e.data.assignments[itervar]
# Remove the condition on the entry edge
condition_edge = sdfg.edges_between(guard, body)[0]
condition_edge.data.condition = CodeBlock("1")
# Get rid of backedge to guard
sdfg.remove_edge(sdfg.edges_between(body, guard)[0])
# Route body directly to after state, maintaining any other assignments
# it might have had
sdfg.add_edge(
body, after,
sd.InterstateEdge(assignments=after_edge.data.assignments))
# If this had made the iteration variable a free symbol, we can remove
# it from the SDFG symbols
if itervar in sdfg.free_symbols:
sdfg.remove_symbol(itervar)
for sym in symbols_to_remove:
if helpers.is_symbol_unused(sdfg, sym):
sdfg.remove_symbol(sym)
def apply(self, sdfg: sd.SDFG):
####################################################################
# Obtain loop information
guard: sd.SDFGState = sdfg.node(self.subgraph[DetectLoop._loop_guard])
begin: sd.SDFGState = sdfg.node(self.subgraph[DetectLoop._loop_begin])
after_state: sd.SDFGState = sdfg.node(
self.subgraph[DetectLoop._exit_state])
# Obtain iteration variable, range, and stride
guard_inedges = sdfg.in_edges(guard)
condition_edge = sdfg.edges_between(guard, begin)[0]
not_condition_edge = sdfg.edges_between(guard, after_state)[0]
itervar = list(guard_inedges[0].data.assignments.keys())[0]
condition = condition_edge.data.condition_sympy()
rng = self._loop_range(itervar, guard_inedges, condition)
# Find the state prior to the loop
if rng[0] == symbolic.pystr_to_symbolic(
guard_inedges[0].data.assignments[itervar]):
init_edge: sd.InterstateEdge = guard_inedges[0]
before_state: sd.SDFGState = guard_inedges[0].src
last_state: sd.SDFGState = guard_inedges[1].src
else:
init_edge: sd.InterstateEdge = guard_inedges[1]
before_state: sd.SDFGState = guard_inedges[1].src
last_state: sd.SDFGState = guard_inedges[0].src
# Get loop states
loop_states = list(
sdutil.dfs_conditional(sdfg,
sources=[begin],
condition=lambda _, child: child != guard))
first_id = loop_states.index(begin)
last_id = loop_states.index(last_state)
loop_subgraph = gr.SubgraphView(sdfg, loop_states)
####################################################################
# Transform
if self.begin:
# If begin, change initialization assignment and prepend states before
# guard
init_edge.data.assignments[itervar] = str(rng[0] +
self.count * rng[2])
append_state = before_state
# Add `count` states, each with instantiated iteration variable
for i in range(self.count):
# Instantiate loop states with iterate value
state_name: str = 'start_' + itervar + str(i * rng[2])
state_name = state_name.replace('-', 'm').replace(
'+', 'p').replace('*', 'M').replace('/', 'D')
new_states = self.instantiate_loop(
sdfg,
loop_states,
loop_subgraph,
itervar,
rng[0] + i * rng[2],
state_name,
)
# Connect states to before the loop with unconditional edges
sdfg.add_edge(append_state, new_states[first_id],
sd.InterstateEdge())
append_state = new_states[last_id]
# Reconnect edge to guard state from last peeled iteration
if append_state != before_state:
sdfg.remove_edge(init_edge)
sdfg.add_edge(append_state, guard, init_edge.data)
else:
# If begin, change initialization assignment and prepend states before
# guard
itervar_sym = pystr_to_symbolic(itervar)
condition_edge.data.condition = CodeBlock(
self._modify_cond(condition_edge.data.condition, itervar,
rng[2]))
not_condition_edge.data.condition = CodeBlock(
self._modify_cond(not_condition_edge.data.condition, itervar,
rng[2]))
prepend_state = after_state
# Add `count` states, each with instantiated iteration variable
for i in reversed(range(self.count)):
# Instantiate loop states with iterate value
state_name: str = 'end_' + itervar + str(-i * rng[2])
state_name = state_name.replace('-', 'm').replace(
'+', 'p').replace('*', 'M').replace('/', 'D')
new_states = self.instantiate_loop(
sdfg,
loop_states,
loop_subgraph,
itervar,
itervar_sym + i * rng[2],
state_name,
)
# Connect states to before the loop with unconditional edges
sdfg.add_edge(new_states[last_id], prepend_state,
sd.InterstateEdge())
prepend_state = new_states[first_id]
# Reconnect edge to guard state from last peeled iteration
if prepend_state != after_state:
sdfg.remove_edge(not_condition_edge)
sdfg.add_edge(guard, prepend_state, not_condition_edge.data)
def find_dead_states(
self,
sdfg: SDFG,
set_unconditional_edges: bool = True) -> Set[SDFGState]:
'''
Finds "dead" (unreachable) states in an SDFG. A state is deemed unreachable if it is:
* Unreachable from the starting state
* Conditions leading to it will always evaluate to False
* There is another unconditional (always True) inter-state edge that leads to another state
:param sdfg: The SDFG to traverse.
:param set_unconditional_edges: If True, conditions of edges evaluated as unconditional are removed.
:return: A set of unreachable states.
'''
visited: Set[SDFGState] = set()
# Run a modified BFS where definitely False edges are not traversed, or if there is an
# unconditional edge the rest are not. The inverse of the visited states is the dead set.
queue = collections.deque([sdfg.start_state])
while len(queue) > 0:
node = queue.popleft()
if node in visited:
continue
visited.add(node)
# First, check for unconditional edges
unconditional = None
for e in sdfg.out_edges(node):
# If an unconditional edge is found, ignore all other outgoing edges
if self.is_definitely_taken(e.data):
# If more than one unconditional outgoing edge exist, fail with Invalid SDFG
if unconditional is not None:
raise InvalidSDFGInterstateEdgeError(
'Multiple unconditional edges leave the same state',
sdfg, sdfg.edge_id(e))
unconditional = e
if set_unconditional_edges and not e.data.is_unconditional(
):
# Annotate edge as unconditional
e.data.condition = CodeBlock('1')
# Continue traversal through edge
if e.dst not in visited:
queue.append(e.dst)
continue
if unconditional is not None: # Unconditional edge exists, skip traversal
continue
# End of unconditional check
# Check outgoing edges normally
for e in sdfg.out_edges(node):
next_node = e.dst
# Test for edges that definitely evaluate to False
if self.is_definitely_not_taken(e.data):
continue
# Continue traversal through edge
if next_node not in visited:
queue.append(next_node)
# Dead states are states that are not live (i.e., visited)
return set(sdfg.nodes()) - visited
def apply(self, _, sdfg: SDFG):
a: SDFGState = self.state_a
b: SDFGState = self.state_b
edge = sdfg.edges_between(a, b)[0]
edge.data.condition = CodeBlock("1")
def apply(self, _, sdfg: sd.SDFG):
####################################################################
# Obtain loop information
guard: sd.SDFGState = self.loop_guard
begin: sd.SDFGState = self.loop_begin
after_state: sd.SDFGState = self.exit_state
# Obtain iteration variable, range, and stride
condition_edge = sdfg.edges_between(guard, begin)[0]
not_condition_edge = sdfg.edges_between(guard, after_state)[0]
itervar, rng, loop_struct = find_for_loop(sdfg, guard, begin)
# Get loop states
loop_states = list(
sdutil.dfs_conditional(sdfg,
sources=[begin],
condition=lambda _, child: child != guard))
first_id = loop_states.index(begin)
last_state = loop_struct[1]
last_id = loop_states.index(last_state)
loop_subgraph = gr.SubgraphView(sdfg, loop_states)
####################################################################
# Transform
if self.begin:
# If begin, change initialization assignment and prepend states before
# guard
init_edges = []
before_states = loop_struct[0]
for before_state in before_states:
init_edge = sdfg.edges_between(before_state, guard)[0]
init_edge.data.assignments[itervar] = str(rng[0] +
self.count * rng[2])
init_edges.append(init_edge)
append_states = before_states
# Add `count` states, each with instantiated iteration variable
for i in range(self.count):
# Instantiate loop states with iterate value
state_name: str = 'start_' + itervar + str(i * rng[2])
state_name = state_name.replace('-', 'm').replace(
'+', 'p').replace('*', 'M').replace('/', 'D')
new_states = self.instantiate_loop(
sdfg,
loop_states,
loop_subgraph,
itervar,
rng[0] + i * rng[2],
state_name,
)
# Connect states to before the loop with unconditional edges
for append_state in append_states:
sdfg.add_edge(append_state, new_states[first_id],
sd.InterstateEdge())
append_states = [new_states[last_id]]
# Reconnect edge to guard state from last peeled iteration
for append_state in append_states:
if append_state not in before_states:
for init_edge in init_edges:
sdfg.remove_edge(init_edge)
sdfg.add_edge(append_state, guard, init_edges[0].data)
else:
# If begin, change initialization assignment and prepend states before
# guard
itervar_sym = pystr_to_symbolic(itervar)
condition_edge.data.condition = CodeBlock(
self._modify_cond(condition_edge.data.condition, itervar,
rng[2]))
not_condition_edge.data.condition = CodeBlock(
self._modify_cond(not_condition_edge.data.condition, itervar,
rng[2]))
prepend_state = after_state
# Add `count` states, each with instantiated iteration variable
for i in reversed(range(self.count)):
# Instantiate loop states with iterate value
state_name: str = 'end_' + itervar + str(-i * rng[2])
state_name = state_name.replace('-', 'm').replace(
'+', 'p').replace('*', 'M').replace('/', 'D')
new_states = self.instantiate_loop(
sdfg,
loop_states,
loop_subgraph,
itervar,
itervar_sym + i * rng[2],
state_name,
)
# Connect states to before the loop with unconditional edges
sdfg.add_edge(new_states[last_id], prepend_state,
sd.InterstateEdge())
prepend_state = new_states[first_id]
# Reconnect edge to guard state from last peeled iteration
if prepend_state != after_state:
sdfg.remove_edge(not_condition_edge)
sdfg.add_edge(guard, prepend_state, not_condition_edge.data)