diff --git a/pyproject.toml b/pyproject.toml index 6f289d2e5a..f7e4ae9d01 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -100,7 +100,7 @@ dependencies = [ 'click>=8.0.0', 'cmake>=3.22', 'cytoolz>=1.0.1', - 'dace>=2.0.0a3', + 'dace>=2.0.0a4', 'deepdiff>=8.1.0', 'devtools>=0.6', 'factory-boy>=3.3.3', @@ -114,6 +114,7 @@ dependencies = [ 'ninja>=1.11', 'numpy>=2.0.0 ; python_version < "3.14"', 'numpy>=2.3.2 ; python_version >= "3.14"', # first version with pre-built wheel for Python 3.14 + 'ordered-set>=4.1.0', 'packaging>=20.0', 'pybind11>=3.0.3', 'setuptools>=77.0.3', diff --git a/src/gt4py/next/program_processors/runners/dace/lowering/gtir_dataflow.py b/src/gt4py/next/program_processors/runners/dace/lowering/gtir_dataflow.py index 2e8983ccb8..0b755d9f03 100644 --- a/src/gt4py/next/program_processors/runners/dace/lowering/gtir_dataflow.py +++ b/src/gt4py/next/program_processors/runners/dace/lowering/gtir_dataflow.py @@ -1004,8 +1004,8 @@ def write_output_of_nested_sdfg_to_temporary(inner_value: ValueExpr) -> ValueExp nsdfg_symbols_mapping["__cond"] = condition_value.value nsdfg_node = self.state.add_nested_sdfg( nsdfg, - inputs=sorted(used_connectivities | input_memlets.keys()), - outputs=sorted(outputs), + inputs={key: None for key in sorted(used_connectivities | input_memlets.keys())}, + outputs={key: None for key in sorted(outputs)}, symbol_mapping=nsdfg_symbols_mapping, ) diff --git a/src/gt4py/next/program_processors/runners/dace/lowering/gtir_to_sdfg.py b/src/gt4py/next/program_processors/runners/dace/lowering/gtir_to_sdfg.py index 223eff2d79..8a8d42f9ba 100644 --- a/src/gt4py/next/program_processors/runners/dace/lowering/gtir_to_sdfg.py +++ b/src/gt4py/next/program_processors/runners/dace/lowering/gtir_to_sdfg.py @@ -766,8 +766,8 @@ def add_nested_sdfg( nsdfg_node = outer_ctx.state.add_nested_sdfg( inner_ctx.sdfg, - inputs=input_memlets.keys(), - outputs=lambda_outputs, + inputs={key: None for key in sorted(input_memlets.keys())}, + outputs={key: None for key in sorted(lambda_outputs)}, symbol_mapping=nsdfg_symbols_mapping, debuginfo=gtir_to_sdfg_utils.debug_info(node, default=outer_ctx.sdfg.debuginfo), ) diff --git a/src/gt4py/next/program_processors/runners/dace/transformations/__init__.py b/src/gt4py/next/program_processors/runners/dace/transformations/__init__.py index 66a24c1ebf..39fb62f1fe 100644 --- a/src/gt4py/next/program_processors/runners/dace/transformations/__init__.py +++ b/src/gt4py/next/program_processors/runners/dace/transformations/__init__.py @@ -84,7 +84,7 @@ gt_propagate_strides_from_access_node, gt_propagate_strides_of, ) -from .utils import gt_make_transients_persistent, unique_name +from .utils import gt_make_transients_persistent __all__ = [ @@ -150,5 +150,4 @@ "gt_vertical_map_split_fusion", "inline_dataflow_into_map", "splitting_tools", - "unique_name", ] diff --git a/src/gt4py/next/program_processors/runners/dace/transformations/auto_optimize.py b/src/gt4py/next/program_processors/runners/dace/transformations/auto_optimize.py index 81f5bfb126..a7b34f6bbf 100644 --- a/src/gt4py/next/program_processors/runners/dace/transformations/auto_optimize.py +++ b/src/gt4py/next/program_processors/runners/dace/transformations/auto_optimize.py @@ -19,7 +19,7 @@ from dace.transformation.auto import auto_optimize as dace_aoptimize from dace.transformation.passes import analysis as dace_analysis -from gt4py.next import common as gtx_common +from gt4py.next import common as gtx_common, utils as gtx_utils from gt4py.next.program_processors.runners.dace import ( library_nodes as gtx_library_nodes, transformations as gtx_transformations, @@ -234,6 +234,7 @@ def gt_auto_optimize( Something along the line "Fuse if operational intensity goes up, but not if we have too much internal space (register pressure). """ + uids = gtx_utils.IDGeneratorPool() device = dace.DeviceType.GPU if gpu else dace.DeviceType.CPU optimization_hooks = optimization_hooks or {} @@ -333,6 +334,7 @@ def gt_auto_optimize( scan_loop_unrolling_factor=scan_loop_unrolling_factor, fuse_tasklets=fuse_tasklets, validate_all=validate_all, + uids=uids, ) # Configure the Maps: @@ -690,6 +692,7 @@ def _gt_auto_process_dataflow_inside_maps( scan_loop_unrolling_factor: int, fuse_tasklets: bool, validate_all: bool, + uids: gtx_utils.IDGeneratorPool, ) -> dace.SDFG: """Optimizes the dataflow inside the top level Maps of the SDFG inplace. @@ -735,7 +738,7 @@ def _gt_auto_process_dataflow_inside_maps( # Constants (tasklets are needed to write them into a variable) should not be # arguments to a kernel but be present inside the body. sdfg.apply_transformations_once_everywhere( - gtx_transformations.GT4PyMoveTaskletIntoMap, + gtx_transformations.GT4PyMoveTaskletIntoMap(uids=uids), validate=False, validate_all=validate_all, ) @@ -762,7 +765,7 @@ def _gt_auto_process_dataflow_inside_maps( # Make sure that this runs before MoveDataflowIntoIfBody because atm it doesn't handle # NestedSDFGs inside the ConditionalBlocks it fuses. sdfg.apply_transformations_repeated( - gtx_transformations.FuseHorizontalConditionBlocks(), + gtx_transformations.FuseHorizontalConditionBlocks(uids=uids), validate=False, validate_all=validate_all, ) diff --git a/src/gt4py/next/program_processors/runners/dace/transformations/fuse_horizontal_conditionblocks.py b/src/gt4py/next/program_processors/runners/dace/transformations/fuse_horizontal_conditionblocks.py index ef0e64d05b..98ddbbb7f1 100644 --- a/src/gt4py/next/program_processors/runners/dace/transformations/fuse_horizontal_conditionblocks.py +++ b/src/gt4py/next/program_processors/runners/dace/transformations/fuse_horizontal_conditionblocks.py @@ -14,6 +14,7 @@ from dace.sdfg import graph as dace_graph, nodes as dace_nodes from dace.transformation import helpers as dace_helpers +from gt4py.next import utils as gtx_utils from gt4py.next.program_processors.runners.dace import transformations as gtx_transformations @@ -50,6 +51,11 @@ class FuseHorizontalConditionBlocks(dace_transformation.SingleStateTransformatio conditional_access_node = dace_transformation.PatternNode(dace_nodes.AccessNode) nsdfg_a = dace_transformation.PatternNode(dace_nodes.NestedSDFG) nsdfg_b = dace_transformation.PatternNode(dace_nodes.NestedSDFG) + _uids: gtx_utils.IDGeneratorPool + + def __init__(self, *args: Any, uids: gtx_utils.IDGeneratorPool, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + self._uids = uids # The fusion of the two conditional blocks can happen in any order. To avoid any indeterminism distinguish which one is the fused and which one is the extended conditional block which will include the fused one. @staticmethod @@ -293,7 +299,7 @@ def apply( for data_name, data_desc in fused_conditional_block.sdfg.arrays.items(): if data_name == "__cond": continue - new_data_name = gtx_transformations.utils.unique_name(data_name) + "_from_cb_fusion" + new_data_name = next(self._uids[f"{data_name}_from_cb_fusion"]) data_desc_renamed = copy.deepcopy(data_desc) second_arrays_rename_map[data_name] = ( nested_sdfg_of_extended_conditional_block.sdfg.add_datadesc( diff --git a/src/gt4py/next/program_processors/runners/dace/transformations/inline_fuser.py b/src/gt4py/next/program_processors/runners/dace/transformations/inline_fuser.py index 1c630132e9..f02af633dd 100644 --- a/src/gt4py/next/program_processors/runners/dace/transformations/inline_fuser.py +++ b/src/gt4py/next/program_processors/runners/dace/transformations/inline_fuser.py @@ -6,6 +6,8 @@ # Please, refer to the LICENSE file in the root directory. # SPDX-License-Identifier: BSD-3-Clause +from __future__ import annotations + import copy import warnings from typing import Final, Iterable, Optional, Sequence, TypeAlias @@ -14,6 +16,7 @@ import sympy from dace import data as dace_data, subsets as dace_sbs, symbolic as dace_sym from dace.sdfg import graph as dace_graph, nodes as dace_nodes +from ordered_set import OrderedSet from gt4py.next.program_processors.runners.dace import transformations as gtx_transformations @@ -73,7 +76,7 @@ def perform_dataflow_inlining( sdfg: dace.SDFG, state: dace.SDFGState, edge: dace_graph.MultiConnectorEdge[dace.Memlet], - nodes_to_inline: set[dace_nodes.Node], + nodes_to_inline: OrderedSet[dace_nodes.Node], inline_spec: InlineSpec, ) -> Optional[tuple[dace_nodes.NestedSDFG, dace_nodes.AccessNode]]: """Performs the second step, i.e. the actual inlining, of the dataflow. @@ -134,7 +137,7 @@ def find_nodes_to_inline( sdfg: dace.SDFG, state: dace.SDFGState, edge: dace_graph.MultiConnectorEdge[dace.Memlet], -) -> Optional[tuple[set[dace_nodes.Node], InlineSpec]]: +) -> Optional[tuple[OrderedSet[dace_nodes.Node], InlineSpec]]: """First step of dataflow inlining, computing the inline specification. The inline specification describes how the inlining of dataflow has to be done. @@ -477,7 +480,7 @@ def _insert_nested_sdfg( def _populate_nested_sdfg( sdfg: dace.SDFG, state: dace.SDFGState, - nodes_to_replicate: set[dace_nodes.Node], + nodes_to_replicate: OrderedSet[dace_nodes.Node], first_map_exit: dace_nodes.MapExit, exchange_subset: dace_sbs.Range, intermediate_node: dace_nodes.AccessNode, diff --git a/src/gt4py/next/program_processors/runners/dace/transformations/map_fusion_utils.py b/src/gt4py/next/program_processors/runners/dace/transformations/map_fusion_utils.py index 2be9bbaede..9cd4368415 100644 --- a/src/gt4py/next/program_processors/runners/dace/transformations/map_fusion_utils.py +++ b/src/gt4py/next/program_processors/runners/dace/transformations/map_fusion_utils.py @@ -78,8 +78,8 @@ def _new_name(old_name: str) -> str: elif isinstance(node, dace_nodes.NestedSDFG): node_ = graph.add_nested_sdfg( sdfg=copy.deepcopy(node.sdfg), - inputs=set(node.in_connectors.keys()), - outputs=set(node.out_connectors.keys()), + inputs={k: None for k in sorted(node.in_connectors.keys())}, + outputs={k: None for k in sorted(node.out_connectors.keys())}, symbol_mapping=node.symbol_mapping.copy(), debuginfo=copy.copy(node.debuginfo), ) @@ -224,8 +224,7 @@ def split_overlapping_map_range( first_map_splitted_dict = {} second_map_splitted_dict = {} - for param in first_map_params: - first_map_range = first_map_dict[param] + for param, first_map_range in first_map_dict.items(): second_map_range = second_map_dict[param] if (step := first_map_range[2]) != second_map_range[2]: # we do not support splitting of map range when the range step is different diff --git a/src/gt4py/next/program_processors/runners/dace/transformations/move_dataflow_into_if_body.py b/src/gt4py/next/program_processors/runners/dace/transformations/move_dataflow_into_if_body.py index e217395ee8..8742f1dc6a 100644 --- a/src/gt4py/next/program_processors/runners/dace/transformations/move_dataflow_into_if_body.py +++ b/src/gt4py/next/program_processors/runners/dace/transformations/move_dataflow_into_if_body.py @@ -6,6 +6,8 @@ # Please, refer to the LICENSE file in the root directory. # SPDX-License-Identifier: BSD-3-Clause +from __future__ import annotations + import collections import copy import functools @@ -24,6 +26,7 @@ type_inference as dace_type_inference, utils as dace_sutils, ) +from ordered_set import OrderedSet from gt4py.next.program_processors.runners.dace import transformations as gtx_transformations @@ -717,8 +720,8 @@ def _filter_relocatable_dataflow( sdfg: dace.SDFG, state: dace.SDFGState, if_block: dace_nodes.NestedSDFG, - raw_relocatable_dataflow: dict[str, set[dace_nodes.Node]], - non_relocatable_dataflow: dict[str, set[dace_nodes.Node]], + raw_relocatable_dataflow: dict[str, OrderedSet[dace_nodes.Node]], + non_relocatable_dataflow: dict[str, OrderedSet[dace_nodes.Node]], connector_usage_location: dict[str, tuple[dace.SDFGState, dace_nodes.AccessNode]], enclosing_map: dace_nodes.MapEntry, ) -> set[dace_nodes.Node]: diff --git a/src/gt4py/next/program_processors/runners/dace/transformations/multi_state_global_self_copy_elimination.py b/src/gt4py/next/program_processors/runners/dace/transformations/multi_state_global_self_copy_elimination.py index 7854299780..bb7dcdf44b 100644 --- a/src/gt4py/next/program_processors/runners/dace/transformations/multi_state_global_self_copy_elimination.py +++ b/src/gt4py/next/program_processors/runners/dace/transformations/multi_state_global_self_copy_elimination.py @@ -94,10 +94,10 @@ def modifies(self) -> dace_ppl.Modifies: def should_reapply(self, modified: dace_ppl.Modifies) -> bool: return modified & (dace_ppl.Modifies.Memlets | dace_ppl.Modifies.AccessNodes) - def depends_on(self) -> set[type[dace_transformation.Pass]]: - return { + def depends_on(self) -> list[type[dace_transformation.Pass]]: + return [ dace_transformation.passes.FindAccessStates, - } + ] def apply_pass( self, sdfg: dace.SDFG, pipeline_results: dict[str, Any] diff --git a/src/gt4py/next/program_processors/runners/dace/transformations/simplify.py b/src/gt4py/next/program_processors/runners/dace/transformations/simplify.py index 8c08f3459a..4361c5f1b3 100644 --- a/src/gt4py/next/program_processors/runners/dace/transformations/simplify.py +++ b/src/gt4py/next/program_processors/runners/dace/transformations/simplify.py @@ -10,7 +10,6 @@ import collections import copy -import uuid import warnings from typing import Any, Iterable, Optional, TypeAlias @@ -29,6 +28,7 @@ passes as dace_passes, ) +from gt4py.next import utils as gtx_utils from gt4py.next.program_processors.runners.dace import transformations as gtx_transformations @@ -551,11 +551,11 @@ def modifies(self) -> dace_ppl.Modifies: def should_reapply(self, modified: dace_ppl.Modifies) -> bool: return modified & (dace_ppl.Modifies.Memlets | dace_ppl.Modifies.AccessNodes) - def depends_on(self) -> set[type[dace_transformation.Pass]]: - return { + def depends_on(self) -> list[type[dace_transformation.Pass]]: + return [ dace_transformation.passes.StateReachability, dace_transformation.passes.FindAccessStates, - } + ] def apply_pass( self, sdfg: dace.SDFG, pipeline_results: dict[str, Any] @@ -933,13 +933,16 @@ class GT4PyMoveTaskletIntoMap(dace_transformation.SingleStateTransformation): tasklet = dace_transformation.PatternNode(dace_nodes.Tasklet) access_node = dace_transformation.PatternNode(dace_nodes.AccessNode) map_entry = dace_transformation.PatternNode(dace_nodes.MapEntry) + _uids: gtx_utils.IDGeneratorPool def __init__( self, *args: Any, + uids: gtx_utils.IDGeneratorPool, **kwargs: Any, ) -> None: super().__init__(*args, **kwargs) + self._uids = uids @classmethod def expressions(cls) -> Any: @@ -1008,7 +1011,7 @@ def apply( # This is the tasklet that we will put inside the map, note we have to do it # this way to avoid some name clash stuff. inner_tasklet: dace_nodes.Tasklet = graph.add_tasklet( - name=f"{tasklet.label}__clone_{str(uuid.uuid1()).replace('-', '_')}", + name=next(self._uids[f"{tasklet.label}__clone"]), outputs=tasklet.out_connectors.keys(), inputs=set(), code=tasklet.code, @@ -1157,8 +1160,8 @@ def __init__( def expressions(cls) -> Any: return [dace.sdfg.utils.node_path_graph(cls.map_exit, cls.tmp_ac, cls.glob_ac)] - def depends_on(self) -> set[type[dace_transformation.Pass]]: - return {dace_transformation.passes.ConsolidateEdges} + def depends_on(self) -> list[type[dace_transformation.Pass]]: + return [dace_transformation.passes.ConsolidateEdges] def can_be_applied( self, diff --git a/src/gt4py/next/program_processors/runners/dace/transformations/split_access_nodes.py b/src/gt4py/next/program_processors/runners/dace/transformations/split_access_nodes.py index 177897ed83..e55ff4d1b7 100644 --- a/src/gt4py/next/program_processors/runners/dace/transformations/split_access_nodes.py +++ b/src/gt4py/next/program_processors/runners/dace/transformations/split_access_nodes.py @@ -6,6 +6,8 @@ # Please, refer to the LICENSE file in the root directory. # SPDX-License-Identifier: BSD-3-Clause +from __future__ import annotations + import warnings from typing import Any, Iterable, Optional @@ -17,6 +19,7 @@ ) from dace.sdfg import graph as dace_graph, nodes as dace_nodes from dace.transformation.passes import analysis as dace_analysis +from ordered_set import OrderedSet from gt4py.next.program_processors.runners.dace import transformations as gtx_transformations from gt4py.next.program_processors.runners.dace.transformations import ( @@ -148,7 +151,7 @@ def _apply_split_access_node_non_recursive( class SplitAccessNode(dace_transformation.SingleStateTransformation): """The transformation will split an AccessNode into multiple ones. - If there is no interesection between a write and different reads, + If there is no intersection between a write and different reads, i.e. if every read to the AccessNode can be satisfied by a single write to the AccessNode and the AccessNode is only used at one location, then the node is split. @@ -307,7 +310,7 @@ def apply( def _find_edge_reassignment( self, state: dace.SDFGState, - ) -> dict[dace_graph.MultiConnectorEdge, set[dace_graph.MultiConnectorEdge]] | None: + ) -> dict[dace_graph.MultiConnectorEdge, OrderedSet[dace_graph.MultiConnectorEdge]] | None: """Determine how the edges should be distributed to the fragments. The current implementation defines the fragments, i.e. the pieces into @@ -335,14 +338,14 @@ def _find_edge_reassignment( # generate the data for a consumer). This is hard to handle, but should # be implemented at some point. edge_reassignments: dict[ - dace_graph.MultiConnectorEdge, set[dace_graph.MultiConnectorEdge] + dace_graph.MultiConnectorEdge, OrderedSet[dace_graph.MultiConnectorEdge] ] = {} for iedge in state.in_edges(access_node): if iedge.data.dst_subset is None: return None # TODO(phimuell): Lift this. if iedge.data.wcr is not None: return None - edge_reassignments[iedge] = set() + edge_reassignments[iedge] = OrderedSet() # Now match the outgoing edges to their incoming producers. for oedge in state.out_edges(access_node): @@ -426,7 +429,9 @@ def _check_split_constraints( self, state: dace.SDFGState, sdfg: dace.SDFG, - edge_reassignments: dict[dace_graph.MultiConnectorEdge, set[dace_graph.MultiConnectorEdge]], + edge_reassignments: dict[ + dace_graph.MultiConnectorEdge, OrderedSet[dace_graph.MultiConnectorEdge] + ], ) -> bool: """Checks if the decomposition results in a valid SDFG. diff --git a/src/gt4py/next/program_processors/runners/dace/transformations/splitting_tools.py b/src/gt4py/next/program_processors/runners/dace/transformations/splitting_tools.py index 4340bad394..167678f5f2 100644 --- a/src/gt4py/next/program_processors/runners/dace/transformations/splitting_tools.py +++ b/src/gt4py/next/program_processors/runners/dace/transformations/splitting_tools.py @@ -6,6 +6,8 @@ # Please, refer to the LICENSE file in the root directory. # SPDX-License-Identifier: BSD-3-Clause +from __future__ import annotations + import copy import dataclasses from typing import Any, Iterable, Optional, Sequence, Union @@ -13,6 +15,7 @@ import dace from dace import data as dace_data, subsets as dace_sbs, symbolic as dace_sym from dace.sdfg import graph as dace_graph, nodes as dace_nodes +from ordered_set import OrderedSet from gt4py.next.program_processors.runners.dace import transformations as gtx_transformations @@ -678,7 +681,7 @@ def _perform_node_split( sdfg: dace.SDFG, node_to_split: dace_nodes.AccessNode, new_access_nodes: dict[dace_sbs.Subset, dace_nodes.AccessNode], - assignment: dict[dace_sbs.Subset, set[EdgeConnectionSpec]], + assignment: dict[dace_sbs.Subset, OrderedSet[EdgeConnectionSpec]], allow_to_bypass_nodes: bool, already_reconfigured_nodes: set[tuple[dace_nodes.Node, str]], ) -> None: @@ -858,7 +861,7 @@ def _perform_node_split_with_bypass_impl( state: dace.SDFGState, sdfg: dace.SDFG, node_to_split: dace_nodes.AccessNode, - edges_to_relocate: set[EdgeConnectionSpec], + edges_to_relocate: OrderedSet[EdgeConnectionSpec], already_reconfigured_nodes: set[tuple[dace_nodes.Node, str]], ) -> list[dace_graph.MultiConnectorEdge]: """Performs the splitting but the edge might go directly to the consumer.""" @@ -1049,14 +1052,14 @@ def _generate_data_descriptors_for_split( def _compute_assignement_for_split( edge_descriptions: Sequence[EdgeConnectionSpec], split_description: Sequence[dace_sbs.Subset], -) -> dict[dace_sbs.Subset, set[EdgeConnectionSpec]]: +) -> dict[dace_sbs.Subset, OrderedSet[EdgeConnectionSpec]]: """For every subset, that defines a split find the set of edges that belongs into it. Note that it might happens that some splits have zero assigned edges. """ assert all(split is not None for split in split_description) - assignment: dict[dace_sbs.Subset, set[EdgeConnectionSpec]] = { - split: set() for split in split_description + assignment: dict[dace_sbs.Subset, OrderedSet[EdgeConnectionSpec]] = { + split: OrderedSet() for split in split_description } for edge_description in edge_descriptions: diff --git a/src/gt4py/next/program_processors/runners/dace/transformations/utils.py b/src/gt4py/next/program_processors/runners/dace/transformations/utils.py index c74c19092e..80cdda5d06 100644 --- a/src/gt4py/next/program_processors/runners/dace/transformations/utils.py +++ b/src/gt4py/next/program_processors/runners/dace/transformations/utils.py @@ -8,7 +8,8 @@ """Common functionality for the transformations/optimization pipeline.""" -import uuid +from __future__ import annotations + from typing import Optional, Sequence, TypeVar, Union import dace @@ -17,6 +18,7 @@ from dace.sdfg import graph as dace_graph, nodes as dace_nodes from dace.transformation import pass_pipeline as dace_ppl from dace.transformation.passes import analysis as dace_analysis +from ordered_set import OrderedSet from gt4py.next.program_processors.runners.dace import library_nodes as gtx_lib @@ -24,21 +26,6 @@ _PassT = TypeVar("_PassT", bound=dace_ppl.Pass) -def unique_name(name: str) -> str: - """Adds a unique string to `name`. - - Note: - The names generates by this function are rather unstable and it should - not be used if a particular order should be enforced. This function is - marked for deprecation. - """ - maximal_length = 200 - unique_sufix = str(uuid.uuid1()).replace("-", "_") - if len(name) > (maximal_length - len(unique_sufix)): - name = name[: (maximal_length - len(unique_sufix) - 1)] - return f"{name}_{unique_sufix}" - - def gt_make_transients_persistent( sdfg: dace.SDFG, device: dace.DeviceType, @@ -585,7 +572,7 @@ def find_upstream_nodes( state: dace.SDFGState, start_connector: Optional[str] = None, limit_node: Optional[dace_nodes.Node] = None, -) -> set[dace_nodes.Node]: +) -> OrderedSet[dace_nodes.Node]: """Finds all upstream nodes, i.e. all producers, of `start`. Note that `start` and `limit_node` are not part of the returned set. @@ -598,7 +585,7 @@ def find_upstream_nodes( limit_node: Consider this node as "limiting wall", i.e. do not explore beyond it. """ - seen: set[dace_nodes.Node] = set() + seen: OrderedSet[dace_nodes.Node] = OrderedSet() to_visit = [ iedge.src diff --git a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_auto_optimizer_hooks.py b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_auto_optimizer_hooks.py index 03e94b2858..3f686ae583 100644 --- a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_auto_optimizer_hooks.py +++ b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_auto_optimizer_hooks.py @@ -21,7 +21,7 @@ def _make_sdfg() -> tuple[dace.SDFG, dace.SDFGState]: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("test")) + sdfg = dace.SDFG(util.unique_name("test")) state = sdfg.add_state(is_start_block=True) for name in "abcde": diff --git a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_concat_where_replacer.py b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_concat_where_replacer.py index 738ff5fd29..818ae02100 100644 --- a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_concat_where_replacer.py +++ b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_concat_where_replacer.py @@ -26,9 +26,7 @@ def _make_concat_where_different_inputs() -> tuple[ dace.SDFG, dace.SDFGState, dace_nodes.AccessNode, dace_nodes.MapEntry ]: - sdfg = dace.SDFG( - gtx_transformations.utils.unique_name("concat_where_replacer_different_inputs") - ) + sdfg = dace.SDFG(util.unique_name("concat_where_replacer_different_inputs")) state = sdfg.add_state() for name in "abcde": sdfg.add_array( @@ -100,7 +98,7 @@ def test_concat_where_different_inputs(): def _make_concat_where_same_inputs() -> tuple[ dace.SDFG, dace.SDFGState, dace_nodes.AccessNode, dace_nodes.MapEntry, dace_nodes.AccessNode ]: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("concat_where_replacer_same_inputs")) + sdfg = dace.SDFG(util.unique_name("concat_where_replacer_same_inputs")) state = sdfg.add_state() for name in "abcd": sdfg.add_array( @@ -193,9 +191,7 @@ def test_concat_where_same_inputs(): def _make_concat_where_different_sized_sources() -> tuple[ dace.SDFG, dace.SDFGState, dace_nodes.AccessNode, dace_nodes.MapEntry ]: - sdfg = dace.SDFG( - gtx_transformations.utils.unique_name("concat_where_replacer_different_sized_sources") - ) + sdfg = dace.SDFG(util.unique_name("concat_where_replacer_different_sized_sources")) state = sdfg.add_state() shapes = {"a": (7,), "b": (5,), "c": (10,), "d": (10,), "e": (10,)} for name, shape in shapes.items(): @@ -268,7 +264,7 @@ def test_concat_where_different_sized_sources(): def _make_concat_where_mixed_inputs() -> tuple[ dace.SDFG, dace.SDFGState, dace_nodes.AccessNode, dace_nodes.MapEntry, dace_nodes.AccessNode ]: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("concat_where_replacer_mixed_inputs")) + sdfg = dace.SDFG(util.unique_name("concat_where_replacer_mixed_inputs")) state = sdfg.add_state() for name in "abcd": sdfg.add_array( @@ -364,9 +360,7 @@ def test_concat_where_mixed_inputs(): def _make_concat_where_no_mapping_reuse() -> tuple[ dace.SDFG, dace.SDFGState, dace_nodes.AccessNode, dace_nodes.MapEntry, dace_nodes.AccessNode ]: - sdfg = dace.SDFG( - gtx_transformations.utils.unique_name("concat_where_replacer_no_mapping_reuse") - ) + sdfg = dace.SDFG(util.unique_name("concat_where_replacer_no_mapping_reuse")) state = sdfg.add_state() for name in "abcd": sdfg.add_array( @@ -443,9 +437,7 @@ def test_concat_where_additional_mapping_needed(): def _make_concat_where_non_canonical_memlet_sdfg() -> tuple[ dace.SDFG, dace.SDFGState, dace_nodes.AccessNode, dace_nodes.MapEntry, dace_nodes.AccessNode ]: - sdfg = dace.SDFG( - gtx_transformations.utils.unique_name("concat_where_replacer_non_canonical_memlet") - ) + sdfg = dace.SDFG(util.unique_name("concat_where_replacer_non_canonical_memlet")) state = sdfg.add_state() for name in "abcd": sdfg.add_array( @@ -544,9 +536,7 @@ def test_concat_where_non_canonical_memlet_sdfg(): def _make_concat_where_multiple_nested_consumers( uniform_access: bool, ) -> tuple[dace.SDFG, dace.SDFGState, dace_nodes.AccessNode, dace_nodes.MapEntry]: - sdfg = dace.SDFG( - gtx_transformations.utils.unique_name("concat_where_replacer_multiple_consumer") - ) + sdfg = dace.SDFG(util.unique_name("concat_where_replacer_multiple_consumer")) state = sdfg.add_state() for name in "abcde": sdfg.add_array( @@ -647,7 +637,7 @@ def _make_concat_where_nested_scopes() -> tuple[ dace_nodes.MapEntry, dace_nodes.Tasklet, ]: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("concat_where_replacer_nested_consumer")) + sdfg = dace.SDFG(util.unique_name("concat_where_replacer_nested_consumer")) state = sdfg.add_state() for name in "abcd": sdfg.add_array( @@ -740,7 +730,7 @@ def _make_concat_where_multiple_nested_scopes( dace_nodes.MapEntry, dace_nodes.Tasklet, ]: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("concat_where_replacer_nested_consumer")) + sdfg = dace.SDFG(util.unique_name("concat_where_replacer_nested_consumer")) state = sdfg.add_state() for name in "abcd": sdfg.add_array( @@ -874,7 +864,7 @@ def _make_concat_where_global_read( dace.SDFGState, dace_nodes.AccessNode, ]: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("concat_where_replacer_global_consumer")) + sdfg = dace.SDFG(util.unique_name("concat_where_replacer_global_consumer")) state = sdfg.add_state() for aname in "abcd": sdfg.add_array( @@ -1045,9 +1035,7 @@ def _make_concat_where_single_nested_sdfg_consumer( ]: assert binary_ops or (not rename_bin_data), "This configuration does not make sense." - sdfg = dace.SDFG( - gtx_transformations.utils.unique_name("concat_where_replacer_single_nested_sdfg_consumer") - ) + sdfg = dace.SDFG(util.unique_name("concat_where_replacer_single_nested_sdfg_consumer")) state = sdfg.add_state() for aname in "abcd": sdfg.add_array( @@ -1280,9 +1268,7 @@ def make_second_level() -> dace.SDFG: return sdfg - sdfg = dace.SDFG( - gtx_transformations.utils.unique_name("concat_where_replacer_single_multi_level") - ) + sdfg = dace.SDFG(util.unique_name("concat_where_replacer_single_multi_level")) state = sdfg.add_state() for aname in "abcdefghj": @@ -1378,7 +1364,7 @@ def make_single_element_consumer(name) -> dace.SDFG: sdfg.validate() return sdfg - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("nested_single_element_consumer")) + sdfg = dace.SDFG(util.unique_name("nested_single_element_consumer")) state = sdfg.add_state() for aname in "abcd": sdfg.add_array( @@ -1498,9 +1484,7 @@ def make_nested_sdfg() -> dace.SDFG: return sdfg - sdfg = dace.SDFG( - gtx_transformations.utils.unique_name("concat_where_nested_with_symbolic_bound") - ) + sdfg = dace.SDFG(util.unique_name("concat_where_nested_with_symbolic_bound")) state = sdfg.add_state() for aname in "abcd": sdfg.add_array( @@ -1615,9 +1599,7 @@ def make_nested_sdfg() -> dace.SDFG: return sdfg - sdfg = dace.SDFG( - gtx_transformations.utils.unique_name("concat_where_nested_with_symbolic_top_level_size") - ) + sdfg = dace.SDFG(util.unique_name("concat_where_nested_with_symbolic_top_level_size")) state = sdfg.add_state() for sym in [symbolic_size, inc_symb]: sdfg.add_symbol(sym, dace.int32) @@ -1696,7 +1678,7 @@ def _make_multi_producer_sdfg( ) -> tuple[dace.SDFG, dace.SDFGState, dace_nodes.AccessNode]: N = nb_producers * 5 - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("multi_output")) + sdfg = dace.SDFG(util.unique_name("multi_output")) state = sdfg.add_state() output_data = "output" diff --git a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_copy_chain_remover.py b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_copy_chain_remover.py index 7bb46d302b..53bba67408 100644 --- a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_copy_chain_remover.py +++ b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_copy_chain_remover.py @@ -29,7 +29,7 @@ def _make_simple_linear_chain_sdfg() -> dace.SDFG: All intermediates have the same size. """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("simple_linear_chain_sdfg")) + sdfg = dace.SDFG(util.unique_name("simple_linear_chain_sdfg")) for name in ["a", "b", "c", "d", "e"]: sdfg.add_array( @@ -75,7 +75,7 @@ def _make_diff_sizes_pull_chain_sdfg() -> tuple[ - The AccessNode that is used as final output, refers to `e`. - The Tasklet that is within the Map. """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("diff_size_linear_pull_chain_sdfg")) + sdfg = dace.SDFG(util.unique_name("diff_size_linear_pull_chain_sdfg")) array_size_increment = 10 array_size = 10 @@ -118,7 +118,7 @@ def _make_diff_sizes_push_chain_sdfg() -> tuple[ Same as `_make_simple_linear_pull_chain_sdfg()` but the intermediates become smaller and smaller, so the full shape of the destination array is always written. """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("diff_size_linear_push_chain_sdfg")) + sdfg = dace.SDFG(util.unique_name("diff_size_linear_push_chain_sdfg")) array_size_decrement = 10 array_size = 50 @@ -155,7 +155,7 @@ def _make_diff_sizes_push_chain_sdfg() -> tuple[ def _make_multi_stage_reduction_sdfg() -> dace.SDFG: """Creates an SDFG that has a two stage copy reduction.""" - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("multi_stage_reduction")) + sdfg = dace.SDFG(util.unique_name("multi_stage_reduction")) state: dace.SDFGState = sdfg.add_state(is_start_block=True) # This is the size of the arrays, if not mentioned here, then its size is 10. @@ -221,7 +221,7 @@ def _make_not_fully_copied() -> dace.SDFG: Make an SDFG where two intermediate array is not fully copied. Thus the transformation only applies once, when `d` is removed. """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("not_fully_copied_intermediate")) + sdfg = dace.SDFG(util.unique_name("not_fully_copied_intermediate")) for name in ["a", "b", "c", "d", "e"]: sdfg.add_array( @@ -257,7 +257,7 @@ def _make_possible_cyclic_sdfg() -> dace.SDFG: If the transformation would remove `a1` then it would create a cycle. Thus the transformation should not apply. """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("possible_cyclic_sdfg")) + sdfg = dace.SDFG(util.unique_name("possible_cyclic_sdfg")) anames = ["i1", "a1", "a2", "o1"] for name in anames: @@ -331,7 +331,7 @@ def make_inner_sdfg() -> dace.SDFG: inner_sdfg = make_inner_sdfg() - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("linear_chain_with_nested_sdfg")) + sdfg = dace.SDFG(util.unique_name("linear_chain_with_nested_sdfg")) state = sdfg.add_state(is_start_block=True) array_size_increment = 10 @@ -370,7 +370,7 @@ def make_inner_sdfg() -> dace.SDFG: def _make_a1_has_output_sdfg() -> dace.SDFG: """Here `a1` has an output degree of 2, one to `a2` and one to another output.""" - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("a1_has_an_additional_output_sdfg")) + sdfg = dace.SDFG(util.unique_name("a1_has_an_additional_output_sdfg")) state = sdfg.add_state(is_start_block=True) # All other arrays have a size of 10. @@ -411,9 +411,7 @@ def _make_copy_chain_with_reduction_node( dace_nodes.AccessNode, dace_nodes.AccessNode, ]: - sdfg = dace.SDFG( - gtx_transformations.utils.unique_name("copy_chain_remover_with_reduction_sdfg") - ) + sdfg = dace.SDFG(util.unique_name("copy_chain_remover_with_reduction_sdfg")) state = sdfg.add_state(is_start_block=True) if output_an_array: diff --git a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_create_local_double_buffering.py b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_create_local_double_buffering.py index 4bb61a01ad..0db2706c0d 100644 --- a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_create_local_double_buffering.py +++ b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_create_local_double_buffering.py @@ -73,7 +73,7 @@ def _create_sdfg_double_read_part_2( def _create_sdfg_double_read( version: int, ) -> dace.SDFG: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name(f"double_read_version_{version}")) + sdfg = dace.SDFG(util.unique_name(f"double_read_version_{version}")) state = sdfg.add_state(is_start_block=True) for name in "AB": sdfg.add_array( @@ -98,7 +98,7 @@ def _create_sdfg_double_read( def _create_non_scalar_read() -> dace.SDFG: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name(f"non_scalar_read_sdfg")) + sdfg = dace.SDFG(util.unique_name(f"non_scalar_read_sdfg")) state = sdfg.add_state(is_start_block=True) sdfg.add_array( @@ -145,7 +145,7 @@ def test_local_double_buffering_double_read_sdfg(): def test_local_double_buffering_no_connection(): """There is no direct connection between read and write.""" - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("local_double_buffering_no_connection")) + sdfg = dace.SDFG(util.unique_name("local_double_buffering_no_connection")) state = sdfg.add_state(is_start_block=True) for name in "AB": sdfg.add_array( @@ -212,7 +212,7 @@ def test_local_double_buffering_no_connection(): def test_local_double_buffering_no_apply(): """Here it does not apply, because are all distinct.""" - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("local_double_buffering_no_apply")) + sdfg = dace.SDFG(util.unique_name("local_double_buffering_no_apply")) state = sdfg.add_state(is_start_block=True) for name in "AB": sdfg.add_array( @@ -237,7 +237,7 @@ def test_local_double_buffering_no_apply(): def test_local_double_buffering_already_buffered(): """It is already buffered.""" - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("local_double_buffering_no_apply")) + sdfg = dace.SDFG(util.unique_name("local_double_buffering_no_apply")) state = sdfg.add_state(is_start_block=True) sdfg.add_array( "A", diff --git a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_dead_dataflow_elimination.py b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_dead_dataflow_elimination.py index 375f8da1d5..ef13fd6ea7 100644 --- a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_dead_dataflow_elimination.py +++ b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_dead_dataflow_elimination.py @@ -19,7 +19,7 @@ def _make_empty_memlets_sdfg() -> tuple[dace.SDFG, dace.SDFGState]: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("empty_memlets")) + sdfg = dace.SDFG(util.unique_name("empty_memlets")) state = sdfg.add_state(is_start_block=True) anames = ["a", "b", "c"] @@ -46,7 +46,7 @@ def _make_empty_memlets_sdfg() -> tuple[dace.SDFG, dace.SDFGState]: def _make_zero_iter_step_map() -> tuple[dace.SDFG, dace.SDFGState]: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("empty_map")) + sdfg = dace.SDFG(util.unique_name("empty_map")) state = sdfg.add_state(is_start_block=True) anames = ["a", "b", "c"] diff --git a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_distributed_buffer_relocator.py b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_distributed_buffer_relocator.py index a2673295a8..cadf525159 100644 --- a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_distributed_buffer_relocator.py +++ b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_distributed_buffer_relocator.py @@ -21,7 +21,7 @@ def _mk_distributed_buffer_sdfg() -> tuple[dace.SDFG, dace.SDFGState, dace.SDFGState]: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("distributed_buffer_sdfg")) + sdfg = dace.SDFG(util.unique_name("distributed_buffer_sdfg")) for name in ["a", "b", "tmp"]: sdfg.add_array(name, shape=(10, 10), dtype=dace.float64, transient=False) @@ -84,9 +84,7 @@ def test_distributed_buffer_remover(): def _make_distributed_buffer_global_memory_data_race_sdfg() -> tuple[dace.SDFG, dace.SDFGState]: - sdfg = dace.SDFG( - gtx_transformations.utils.unique_name("distributed_buffer_global_memory_data_race") - ) + sdfg = dace.SDFG(util.unique_name("distributed_buffer_global_memory_data_race")) arr_names = ["a", "b", "t"] for name in arr_names: sdfg.add_array( @@ -138,9 +136,7 @@ def test_distributed_buffer_global_memory_data_race(): def _make_distributed_buffer_global_memory_data_race_sdfg2() -> tuple[ dace.SDFG, dace.SDFGState, dace.SDFGState ]: - sdfg = dace.SDFG( - gtx_transformations.utils.unique_name("distributed_buffer_global_memory_data_race2_sdfg") - ) + sdfg = dace.SDFG(util.unique_name("distributed_buffer_global_memory_data_race2_sdfg")) arr_names = ["a", "b", "t"] for name in arr_names: sdfg.add_array( @@ -193,9 +189,7 @@ def test_distributed_buffer_global_memory_data_race2(): def _make_distributed_buffer_global_memory_data_no_rance() -> tuple[dace.SDFG, dace.SDFGState]: - sdfg = dace.SDFG( - gtx_transformations.utils.unique_name("distributed_buffer_global_memory_data_no_rance_sdfg") - ) + sdfg = dace.SDFG(util.unique_name("distributed_buffer_global_memory_data_no_rance_sdfg")) arr_names = ["a", "t"] for name in arr_names: sdfg.add_array( @@ -241,11 +235,7 @@ def test_distributed_buffer_global_memory_data_no_rance(): def _make_distributed_buffer_global_memory_data_no_rance2() -> tuple[dace.SDFG, dace.SDFGState]: - sdfg = dace.SDFG( - gtx_transformations.utils.unique_name( - "distributed_buffer_global_memory_data_no_rance2_sdfg" - ) - ) + sdfg = dace.SDFG(util.unique_name("distributed_buffer_global_memory_data_no_rance2_sdfg")) arr_names = ["a", "t"] for name in arr_names: sdfg.add_array( @@ -301,9 +291,7 @@ def test_distributed_buffer_global_memory_data_no_rance2(): def _make_distributed_buffer_non_sink_temporary_sdfg() -> tuple[ dace.SDFG, dace.SDFGState, dace.SDFGState ]: - sdfg = dace.SDFG( - gtx_transformations.utils.unique_name("distributed_buffer_non_sink_temporary_sdfg") - ) + sdfg = dace.SDFG(util.unique_name("distributed_buffer_non_sink_temporary_sdfg")) state = sdfg.add_state(is_start_block=True) wb_state = sdfg.add_state_after(state) diff --git a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_double_write_remover.py b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_double_write_remover.py index 6579f1219e..da70155cf3 100644 --- a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_double_write_remover.py +++ b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_double_write_remover.py @@ -25,7 +25,7 @@ def _make_double_write_single_consumer( ) -> tuple[ dace.SDFG, dace.SDFGState, dace_nodes.AccessNode, dace_nodes.AccessNode, dace_nodes.MapExit ]: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("double_write_elimination_1")) + sdfg = dace.SDFG(util.unique_name("double_write_elimination_1")) state = sdfg.add_state(is_start_block=True) sdfg.add_array( @@ -148,7 +148,7 @@ def _make_double_write_multi_consumer( dace_nodes.AccessNode, dace_nodes.MapExit, ]: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("double_write_elimination_2")) + sdfg = dace.SDFG(util.unique_name("double_write_elimination_2")) state = sdfg.add_state(is_start_block=True) sdfg.add_array( @@ -255,9 +255,7 @@ def _make_double_write_multi_producer_map( ) -> tuple[ dace.SDFG, dace.SDFGState, dace_nodes.AccessNode, dace_nodes.AccessNode, dace_nodes.MapExit ]: - sdfg = dace.SDFG( - gtx_transformations.utils.unique_name("double_write_elimination_multi_producer_map") - ) + sdfg = dace.SDFG(util.unique_name("double_write_elimination_multi_producer_map")) state = sdfg.add_state(is_start_block=True) sdfg.add_array( diff --git a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_fuse_horizontal_conditionblocks.py b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_fuse_horizontal_conditionblocks.py index b25cb72795..9648081111 100644 --- a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_fuse_horizontal_conditionblocks.py +++ b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_fuse_horizontal_conditionblocks.py @@ -10,8 +10,8 @@ dace = pytest.importorskip("dace") from dace.sdfg import nodes as dace_nodes -from dace.transformation.passes import analysis as dace_analysis +from gt4py.next import utils as gtx_utils from gt4py.next.program_processors.runners.dace import ( transformations as gtx_transformations, ) @@ -34,7 +34,7 @@ def _make_if_block_with_tasklet( b2_type: dace.typeclass = dace.float64, output_type: dace.typeclass = dace.float64, ) -> dace_nodes.NestedSDFG: - inner_sdfg = dace.SDFG(gtx_transformations.utils.unique_name("if_stmt_")) + inner_sdfg = dace.SDFG(util.unique_name("if_stmt_")) types = {b1_name: b1_type, b2_name: b2_type, cond_name: dace.bool_, output_name: output_type} for name in {b1_name, b2_name, cond_name, output_name}: @@ -44,7 +44,7 @@ def _make_if_block_with_tasklet( transient=False, ) - if_region = dace.sdfg.state.ConditionalBlock(gtx_transformations.utils.unique_name("if")) + if_region = dace.sdfg.state.ConditionalBlock(util.unique_name("if")) inner_sdfg.add_node(if_region, is_start_block=True) then_body = dace.sdfg.state.ControlFlowRegion("then_body", sdfg=inner_sdfg) @@ -103,7 +103,7 @@ def _make_map_with_conditional_blocks( with_false_branch: bool = True, with_else_branch: bool = False, ) -> dace.SDFG: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("map_with_conditional_blocks")) + sdfg = dace.SDFG(util.unique_name("map_with_conditional_blocks")) state = sdfg.add_state(is_start_block=True) sdfg.add_array( @@ -210,7 +210,7 @@ def _make_map_with_conditional_blocks( return sdfg -def test_fuse_horizontal_condition_blocks(): +def test_fuse_horizontal_condition_blocks(uids: gtx_utils.IDGeneratorPool): sdfg = _make_map_with_conditional_blocks() conditional_blocks = [ @@ -222,7 +222,7 @@ def test_fuse_horizontal_condition_blocks(): util.compile_and_run_sdfg(sdfg, **ref) sdfg.apply_transformations_repeated( - gtx_transformations.FuseHorizontalConditionBlocks(), + gtx_transformations.FuseHorizontalConditionBlocks(uids=uids), validate=True, validate_all=True, ) @@ -240,7 +240,7 @@ def test_fuse_horizontal_condition_blocks(): assert util.compare_sdfg_res(ref=ref, res=res) -def test_fuse_horizontal_condition_blocks_single_false(): +def test_fuse_horizontal_condition_blocks_single_false(uids: gtx_utils.IDGeneratorPool): """ Test that the transformation can fuse conditional blocks even if one of them does not have a false branch. """ @@ -255,7 +255,7 @@ def test_fuse_horizontal_condition_blocks_single_false(): util.compile_and_run_sdfg(sdfg, **ref) sdfg.apply_transformations_repeated( - gtx_transformations.FuseHorizontalConditionBlocks(), + gtx_transformations.FuseHorizontalConditionBlocks(uids=uids), validate=True, validate_all=True, ) @@ -281,7 +281,7 @@ def test_fuse_horizontal_condition_blocks_single_false(): assert util.compare_sdfg_res(ref=ref, res=res) -def test_fuse_horizontal_condition_blocks_else_branch(): +def test_fuse_horizontal_condition_blocks_else_branch(uids: gtx_utils.IDGeneratorPool): """ Test that the transformation can fuse conditional blocks that instead of a `(not __cond)` condition have an `else` (`None`) condition. @@ -297,7 +297,7 @@ def test_fuse_horizontal_condition_blocks_else_branch(): util.compile_and_run_sdfg(sdfg, **ref) sdfg.apply_transformations_repeated( - gtx_transformations.FuseHorizontalConditionBlocks(), + gtx_transformations.FuseHorizontalConditionBlocks(uids=uids), validate=True, validate_all=True, ) diff --git a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_gpu_utils.py b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_gpu_utils.py index 2fcacd191d..dd4927bb03 100644 --- a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_gpu_utils.py +++ b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_gpu_utils.py @@ -15,7 +15,6 @@ from gt4py.next.program_processors.runners.dace.transformations import ( gpu_utils as gtx_dace_fieldview_gpu_utils, - utils as gtx_transformations_utils, ) from . import util @@ -43,7 +42,7 @@ def _get_trivial_gpu_promotable( tasklet_code: The body of the Tasklet inside the trivial map. trivial_map_range: Range of the trivial map, defaults to `"0"`. """ - sdfg = dace.SDFG(gtx_transformations_utils.unique_name("gpu_promotable_sdfg")) + sdfg = dace.SDFG(util.unique_name("gpu_promotable_sdfg")) state = sdfg.add_state("state", is_start_block=True) sdfg.add_symbol("N", dace.int32) @@ -156,7 +155,7 @@ def test_trivial_gpu_map_promoter_2(): @pytest.mark.parametrize("method", [0, 1]) def test_set_gpu_properties(method: int): """Tests the `gtx_dace_fieldview_gpu_utils.gt_set_gpu_blocksize()`.""" - sdfg = dace.SDFG(gtx_transformations_utils.unique_name("gpu_properties_test")) + sdfg = dace.SDFG(util.unique_name("gpu_properties_test")) state = sdfg.add_state(is_start_block=True) map_entries: dict[int, dace_nodes.MapEntry] = {} @@ -233,7 +232,7 @@ def test_set_gpu_properties(method: int): def test_set_gpu_properties_1D(): """Tests the `gtx_dace_fieldview_gpu_utils.gt_set_gpu_blocksize()` with 1D maps.""" - sdfg = dace.SDFG(gtx_transformations_utils.unique_name("gpu_properties_test")) + sdfg = dace.SDFG(util.unique_name("gpu_properties_test")) state = sdfg.add_state(is_start_block=True) map_entries: dict[int, dace_nodes.MapEntry] = {} @@ -300,7 +299,7 @@ def test_set_gpu_properties_1D(): def test_set_gpu_properties_2D_3D(): """Tests the `gtx_dace_fieldview_gpu_utils.gt_set_gpu_blocksize()` with 2D, 3D and 4D maps.""" - sdfg = dace.SDFG(gtx_transformations_utils.unique_name("gpu_properties_test")) + sdfg = dace.SDFG(util.unique_name("gpu_properties_test")) state = sdfg.add_state(is_start_block=True) map_entries: dict[int, dace_nodes.MapEntry] = {} @@ -356,7 +355,7 @@ def test_set_gpu_properties_2D_3D(): def test_set_gpu_maxnreg(): """Tests if gpu_maxnreg property is set correctly to GPU maps.""" - sdfg = dace.SDFG(gtx_transformations_utils.unique_name("gpu_maxnreg_test")) + sdfg = dace.SDFG(util.unique_name("gpu_maxnreg_test")) state = sdfg.add_state(is_start_block=True) dim = 2 shape = (10,) * (dim - 1) + (1,) diff --git a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_horizontal_map_split_fusion.py b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_horizontal_map_split_fusion.py index 6bad175597..d7fd220b5f 100644 --- a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_horizontal_map_split_fusion.py +++ b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_horizontal_map_split_fusion.py @@ -34,7 +34,7 @@ def _make_sdfg_with_multiple_maps_that_share_inputs( - Outputs: out1[i, j], out2[i, j], out3[i, j], out4[i, j] """ shape = (N, N) - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("multiple_maps")) + sdfg = dace.SDFG(util.unique_name("multiple_maps")) state = sdfg.add_state(is_start_block=True) for name in ["a", "b", "c", "d", "out1", "out2", "out3", "out4"]: diff --git a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_inline_fuser.py b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_inline_fuser.py index 19c4d8e4be..0ebaaab742 100644 --- a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_inline_fuser.py +++ b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_inline_fuser.py @@ -31,7 +31,7 @@ def _create_simple_fusable_sdfg() -> tuple[ dace_nodes.AccessNode, dace_graph.MultiConnectorEdge[dace.Memlet], ]: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name(f"simple_fusable_sdfg")) + sdfg = dace.SDFG(util.unique_name(f"simple_fusable_sdfg")) state = sdfg.add_state(is_start_block=True) for name in "abc": @@ -119,7 +119,7 @@ def _make_laplap_sdfg( dace_graph.MultiConnectorEdge[dace.Memlet], dace_nodes.Tasklet, ]: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name(f"laplap1")) + sdfg = dace.SDFG(util.unique_name(f"laplap1")) state = sdfg.add_state(is_start_block=True) sdfg.add_array( @@ -221,7 +221,7 @@ def _make_multiple_value_read_sdfg( dace_nodes.MapEntry, dace_graph.MultiConnectorEdge[dace.Memlet], ]: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name(f"multiple_value_generator")) + sdfg = dace.SDFG(util.unique_name(f"multiple_value_generator")) state = sdfg.add_state(is_start_block=True) sdfg.add_array( @@ -365,7 +365,7 @@ def test_multiple_value_exchange_partial(): def _make_sdfg_with_dref_tasklet(): - sdfg = dace.SDFG(gtx_transformations.utils.unique_name(f"sdfg_with_dref_target")) + sdfg = dace.SDFG(util.unique_name(f"sdfg_with_dref_target")) state = sdfg.add_state(is_start_block=True) for name in "abc": diff --git a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_loop_blocking.py b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_loop_blocking.py index 1aed515aa1..30bec8d217 100644 --- a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_loop_blocking.py +++ b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_loop_blocking.py @@ -32,7 +32,7 @@ def _get_simple_sdfg() -> tuple[dace.SDFG, Callable[[np.ndarray, np.ndarray], np can be taken out. This is because how it is constructed. However, applying some simplistic transformations will enable the transformation. """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("simple_block_sdfg")) + sdfg = dace.SDFG(util.unique_name("simple_block_sdfg")) state = sdfg.add_state("state", is_start_block=True) sdfg.add_symbol("N", dace.int32) sdfg.add_symbol("M", dace.int32) @@ -55,7 +55,7 @@ def _get_chained_sdfg() -> tuple[dace.SDFG, Callable[[np.ndarray, np.ndarray], n The bottom Tasklet is the only dependent Tasklet. """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("chained_block_sdfg")) + sdfg = dace.SDFG(util.unique_name("chained_block_sdfg")) state = sdfg.add_state("state", is_start_block=True) sdfg.add_symbol("N", dace.int32) sdfg.add_symbol("M", dace.int32) @@ -159,7 +159,7 @@ def _get_sdfg_with_empty_memlet( is either dependent or independent), the access node between the tasklets and the second tasklet that is always dependent. """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("empty_memlet_sdfg")) + sdfg = dace.SDFG(util.unique_name("empty_memlet_sdfg")) state = sdfg.add_state("state", is_start_block=True) sdfg.add_symbol("N", dace.int32) sdfg.add_symbol("M", dace.int32) @@ -404,7 +404,7 @@ def test_direct_map_exit_connection() -> dace.SDFG: Because the tasklet is connected to the map exit it can not be independent. """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("mapped_tasklet_sdfg")) + sdfg = dace.SDFG(util.unique_name("mapped_tasklet_sdfg")) state = sdfg.add_state("state", is_start_block=True) sdfg.add_array("a", (10,), dace.float64, transient=False) sdfg.add_array("b", (10, 30), dace.float64, transient=False) @@ -591,7 +591,7 @@ def _make_loop_blocking_sdfg_with_inner_map( The function will return the SDFG, the state and the map entry for the outer and inner map. """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("sdfg_with_inner_map")) + sdfg = dace.SDFG(util.unique_name("sdfg_with_inner_map")) state = sdfg.add_state(is_start_block=True) for name in "AB": @@ -756,7 +756,7 @@ def _make_loop_blocking_sdfg_with_independent_inner_map() -> tuple[ """ Creates a nested Map that is independent from the blocking parameter. """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("sdfg_with_inner_independent_map")) + sdfg = dace.SDFG(util.unique_name("sdfg_with_inner_independent_map")) state = sdfg.add_state(is_start_block=True) sdfg.add_array("A", shape=(40, 3), dtype=dace.float64, transient=False) @@ -833,7 +833,7 @@ def _make_loop_blocking_with_reduction( Depending on `reduction_is_dependent` the node is either dependent or not. """ sdfg = dace.SDFG( - gtx_transformations.utils.unique_name( + util.unique_name( "sdfg_with_" + ("" if reduction_is_dependent else "in") + "dependent_reduction" ) ) @@ -954,7 +954,7 @@ def _make_mixed_memlet_sdfg( - `tskl1`. - `tskl2`. """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("mixed_memlet_sdfg")) + sdfg = dace.SDFG(util.unique_name("mixed_memlet_sdfg")) state = sdfg.add_state(is_start_block=True) names_array = ["A", "B", "C"] names_scalar = ["tmp1", "tmp2"] @@ -1148,7 +1148,7 @@ def test_loop_blocking_mixed_memlets_2(): def test_loop_blocking_no_independent_nodes(): import dace - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("mixed_memlet_sdfg")) + sdfg = dace.SDFG(util.unique_name("mixed_memlet_sdfg")) state = sdfg.add_state(is_start_block=True) names = ["A", "B", "C"] for aname in names: @@ -1210,7 +1210,7 @@ def test_loop_blocking_no_independent_nodes(): def _make_only_last_two_elements_sdfg() -> dace.SDFG: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("simple_block_sdfg")) + sdfg = dace.SDFG(util.unique_name("simple_block_sdfg")) state = sdfg.add_state("state", is_start_block=True) sdfg.add_symbol("N", dace.int32) sdfg.add_symbol("B", dace.int32) @@ -1279,7 +1279,7 @@ def test_blocking_size_too_big(): Here the blocking size is larger than the size in that dimension. Thus the transformation will not apply. """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("blocking_size_too_large")) + sdfg = dace.SDFG(util.unique_name("blocking_size_too_large")) state = sdfg.add_state(is_start_block=True) for name in "ab": @@ -1325,7 +1325,7 @@ def test_blocking_size_too_big(): def _make_loop_blocking_sdfg_with_semi_independent_map() -> tuple[ dace.SDFG, dace.SDFGState, dace_nodes.MapEntry, dace_nodes.MapEntry ]: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("sdfg_with_inner_semi_independent_map")) + sdfg = dace.SDFG(util.unique_name("sdfg_with_inner_semi_independent_map")) state = sdfg.add_state(is_start_block=True) sdfg.add_array("A", shape=(40, 3), dtype=dace.float64, transient=False) @@ -1415,7 +1415,7 @@ def test_loop_blocking_sdfg_with_semi_independent_map(): def _make_loop_blocking_only_independent_inner_map() -> tuple[ dace.SDFG, dace.SDFGState, dace_nodes.MapEntry, dace_nodes.MapEntry ]: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("sdfg_with_only_independent_inner_map")) + sdfg = dace.SDFG(util.unique_name("sdfg_with_only_independent_inner_map")) state = sdfg.add_state(is_start_block=True) sdfg.add_array("A", shape=(40, 3), dtype=dace.float64, transient=False) @@ -1479,7 +1479,7 @@ def _make_loop_blocking_output_access_node( ) -> tuple[ dace.SDFG, dace.SDFGState, dace_nodes.MapEntry, dace_nodes.Tasklet, dace_nodes.AccessNode ]: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("sdfg_with_direct_output_access_node")) + sdfg = dace.SDFG(util.unique_name("sdfg_with_direct_output_access_node")) state = sdfg.add_state(is_start_block=True) sdfg.add_array("A", shape=(40,), dtype=dace.float64, transient=False) diff --git a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_make_transients_persistent.py b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_make_transients_persistent.py index 1e7ce47197..d8cf8e33f8 100644 --- a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_make_transients_persistent.py +++ b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_make_transients_persistent.py @@ -21,9 +21,7 @@ def _make_transients_persistent_inner_access_sdfg() -> tuple[dace.SDFG, dace.SDFGState]: - sdfg = dace.SDFG( - gtx_transformations.utils.unique_name("transients_persistent_inner_access_sdfg") - ) + sdfg = dace.SDFG(util.unique_name("transients_persistent_inner_access_sdfg")) state = sdfg.add_state(is_start_block=True) for name in "abc": diff --git a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_map_buffer_elimination.py b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_map_buffer_elimination.py index 1bf30f3697..aa5fce9d76 100644 --- a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_map_buffer_elimination.py +++ b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_map_buffer_elimination.py @@ -48,7 +48,7 @@ def _make_test_sdfg( if out_offset is None: out_offset = in_offset - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("map_buffer")) + sdfg = dace.SDFG(util.unique_name("map_buffer")) state = sdfg.add_state(is_start_block=True) names = {input_name, tmp_name, output_name} for name in names: @@ -220,7 +220,7 @@ def test_map_buffer_elimination_offset_5(): def test_map_buffer_elimination_not_apply(): """Indirect accessing, because of this the double buffer is needed.""" - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("map_buffer")) + sdfg = dace.SDFG(util.unique_name("map_buffer")) state = sdfg.add_state(is_start_block=True) names = ["A", "tmp", "idx"] @@ -269,7 +269,7 @@ def test_map_buffer_elimination_with_nested_sdfgs(): stride1, stride2, stride3 = [dace.symbol(f"stride{i}", dace.int32) for i in range(3)] # top-level sdfg - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("map_buffer")) + sdfg = dace.SDFG(util.unique_name("map_buffer")) inp, inp_desc = sdfg.add_array("__inp", (10,), dace.float64) out, out_desc = sdfg.add_array( "__out", (10, 10, 10), dace.float64, strides=(stride1, stride2, stride3) @@ -278,14 +278,14 @@ def test_map_buffer_elimination_with_nested_sdfgs(): state = sdfg.add_state() tmp_node = state.add_access(tmp) - nsdfg1 = dace.SDFG(gtx_transformations.utils.unique_name("map_buffer")) + nsdfg1 = dace.SDFG(util.unique_name("map_buffer")) inp1, inp1_desc = nsdfg1.add_array("__inp", (10,), dace.float64) out1, out1_desc = nsdfg1.add_array("__out", (10, 10), dace.float64) tmp1, _ = nsdfg1.add_temp_transient_like(out1_desc) state1 = nsdfg1.add_state() tmp1_node = state1.add_access(tmp1) - nsdfg2 = dace.SDFG(gtx_transformations.utils.unique_name("map_buffer")) + nsdfg2 = dace.SDFG(util.unique_name("map_buffer")) inp2, _ = nsdfg2.add_array("__inp", (10,), dace.float64) out2, out2_desc = nsdfg2.add_array("__out", (10,), dace.float64) tmp2, _ = nsdfg2.add_temp_transient_like(out2_desc) diff --git a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_map_fusion_utils.py b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_map_fusion_utils.py index 3fd392946c..83e0bd921a 100644 --- a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_map_fusion_utils.py +++ b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_map_fusion_utils.py @@ -15,7 +15,6 @@ from gt4py.next.program_processors.runners.dace.transformations import ( map_fusion_utils as gtx_map_fusion_utils, - utils as gtx_transformations_utils, ) import numpy as np @@ -25,7 +24,7 @@ def test_copy_map_graph(): N = dace.symbol("N", dace.int32) - sdfg = dace.SDFG(gtx_transformations_utils.unique_name("copy_map_graph")) + sdfg = dace.SDFG(util.unique_name("copy_map_graph")) A, A_desc = sdfg.add_array("A", [N], dtype=dace.float64) B = sdfg.add_datadesc("B", A_desc.clone()) st = sdfg.add_state() @@ -104,7 +103,7 @@ def test_copy_map_graph(): def test_split_overlapping_map_range(map_ranges): first_ndrange, second_ndrange = map_ranges[0:2] - sdfg = dace.SDFG(gtx_transformations_utils.unique_name("split_overlapping_map_range")) + sdfg = dace.SDFG(util.unique_name("split_overlapping_map_range")) st = sdfg.add_state() first_map_entry, _ = st.add_map("first", first_ndrange) second_map_entry, _ = st.add_map("second", second_ndrange) diff --git a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_map_order.py b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_map_order.py index 95132c39f0..c067e47f4f 100644 --- a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_map_order.py +++ b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_map_order.py @@ -62,7 +62,7 @@ def _perform_reorder_test( def _make_test_sdfg(map_params: list[str]) -> dace.SDFG: """Generate an SDFG for the test.""" - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("gpu_promotable_sdfg")) + sdfg = dace.SDFG(util.unique_name("gpu_promotable_sdfg")) state: dace.SDFGState = sdfg.add_state("state", is_start_block=True) dim = len(map_params) for aname in ["a", "b"]: diff --git a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_map_promoter.py b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_map_promoter.py index cef3058ab0..435c37d629 100644 --- a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_map_promoter.py +++ b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_map_promoter.py @@ -31,7 +31,7 @@ def _make_serial_map_promotion_sdfg( ) -> tuple[dace.SDFG, dace.SDFGState, dace_nodes.MapEntry, dace_nodes.MapEntry]: shape_1d = (N,) shape_2d = (N, N) - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("serial_promotable_sdfg")) + sdfg = dace.SDFG(util.unique_name("serial_promotable_sdfg")) state = sdfg.add_state(is_start_block=True) # 1D Arrays @@ -252,7 +252,7 @@ def test_serial_map_promotion_on_symbolic_range(use_symbolic_range): def test_serial_map_promotion_2d_top_1d_bottom(): """Does not apply because the bottom map needs to be promoted.""" - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("serial_map_promoter_2d_map_on_top")) + sdfg = dace.SDFG(util.unique_name("serial_map_promoter_2d_map_on_top")) state = sdfg.add_state(is_start_block=True) # 2D Arrays @@ -311,7 +311,7 @@ def test_serial_map_promotion_2d_top_1d_bottom(): def _make_horizontal_promoter_sdfg( d1_map_is_vertical: bool, ) -> tuple[dace.SDFG, dace.SDFGState, dace_nodes.MapEntry, dace_nodes.MapEntry]: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("serial_map_promoter_tester")) + sdfg = dace.SDFG(util.unique_name("serial_map_promoter_tester")) state = sdfg.add_state(is_start_block=True) h_idx = gtx_dace_lowering.get_map_variable(gtx_common.Dimension("boden")) @@ -447,9 +447,7 @@ def test_horizonal_promotion_promotion_and_merge(d1_map_is_vertical: bool): def _make_sdfg_different_1d_map_name( d1_map_param: str, ) -> tuple[dace.SDFG, dace.SDFGState]: - sdfg = dace.SDFG( - gtx_transformations.utils.unique_name("serial_map_promoter_different_names_" + d1_map_param) - ) + sdfg = dace.SDFG(util.unique_name("serial_map_promoter_different_names_" + d1_map_param)) state = sdfg.add_state(is_start_block=True) # 1D Arrays diff --git a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_map_splitter.py b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_map_splitter.py index 28f0653922..6d569e79b5 100644 --- a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_map_splitter.py +++ b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_map_splitter.py @@ -22,7 +22,7 @@ def _make_sdfg_simple() -> tuple[dace.SDFG, dace.SDFGState]: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("simple_sdfg")) + sdfg = dace.SDFG(util.unique_name("simple_sdfg")) state = sdfg.add_state(is_start_block=True) for name in "abc": diff --git a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_map_to_copy.py b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_map_to_copy.py index d6dc0ae54a..f4c9020de4 100644 --- a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_map_to_copy.py +++ b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_map_to_copy.py @@ -21,7 +21,7 @@ def _make_sdfg_1( consumer_is_map: bool, ) -> tuple[dace.SDFG, dace.SDFGState]: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("simple_sdfg")) + sdfg = dace.SDFG(util.unique_name("simple_sdfg")) state = sdfg.add_state(is_start_block=True) sdfg.add_array( diff --git a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_move_dataflow_into_if_body.py b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_move_dataflow_into_if_body.py index d7233e8385..5d429aa464 100644 --- a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_move_dataflow_into_if_body.py +++ b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_move_dataflow_into_if_body.py @@ -37,7 +37,7 @@ def _make_if_block( b2_type: dace.typeclass = dace.float64, output_type: dace.typeclass = dace.float64, ) -> dace_nodes.NestedSDFG: - inner_sdfg = dace.SDFG(gtx_transformations.utils.unique_name("if_stmt_")) + inner_sdfg = dace.SDFG(util.unique_name("if_stmt_")) types = {b1_name: b1_type, b2_name: b2_type, cond_name: dace.bool_, output_name: output_type} for name in {b1_name, b2_name, cond_name, output_name}: @@ -47,7 +47,7 @@ def _make_if_block( transient=False, ) - if_region = dace.sdfg.state.ConditionalBlock(gtx_transformations.utils.unique_name("if")) + if_region = dace.sdfg.state.ConditionalBlock(util.unique_name("if")) inner_sdfg.add_node(if_region, is_start_block=True) then_body = dace.sdfg.state.ControlFlowRegion("then_body", sdfg=inner_sdfg) @@ -91,7 +91,7 @@ def _make_if_block_with_different_number_of_outputs_in_branches( output1_type: dace.typeclass = dace.float64, output2_type: dace.typeclass = dace.float64, ) -> dace_nodes.NestedSDFG: - inner_sdfg = dace.SDFG(gtx_transformations.utils.unique_name("if_stmt_")) + inner_sdfg = dace.SDFG(util.unique_name("if_stmt_")) types = { b1_name: b1_type, @@ -108,7 +108,7 @@ def _make_if_block_with_different_number_of_outputs_in_branches( transient=False, ) - if_region = dace.sdfg.state.ConditionalBlock(gtx_transformations.utils.unique_name("if")) + if_region = dace.sdfg.state.ConditionalBlock(util.unique_name("if")) inner_sdfg.add_node(if_region, is_start_block=True) then_body = dace.sdfg.state.ControlFlowRegion("then_body", sdfg=inner_sdfg) @@ -158,7 +158,7 @@ def _make_if_block_with_two_args( b4_type: dace.typeclass = dace.float64, output_type: dace.typeclass = dace.float64, ) -> dace_nodes.NestedSDFG: - inner_sdfg = dace.SDFG(gtx_transformations.utils.unique_name("if_stmt_")) + inner_sdfg = dace.SDFG(util.unique_name("if_stmt_")) types = { b1_name: b1_type, @@ -176,7 +176,7 @@ def _make_if_block_with_two_args( transient=False, ) - if_region = dace.sdfg.state.ConditionalBlock(gtx_transformations.utils.unique_name("if")) + if_region = dace.sdfg.state.ConditionalBlock(util.unique_name("if")) inner_sdfg.add_node(if_region, is_start_block=True) then_body = dace.sdfg.state.ControlFlowRegion("then_body", sdfg=inner_sdfg) @@ -264,7 +264,7 @@ def test_if_mover_independent_branches(): d = b ``` """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("independent_branches")) + sdfg = dace.SDFG(util.unique_name("independent_branches")) state = sdfg.add_state(is_start_block=True) # Inputs @@ -375,7 +375,7 @@ def test_if_mover_independent_branches(): def test_if_mover_invalid_if_block(): - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("invalid")) + sdfg = dace.SDFG(util.unique_name("invalid")) state = sdfg.add_state(is_start_block=True) input_names = ["a", "b", "c", "d"] @@ -484,7 +484,7 @@ def test_if_mover_dependent_branch_1(): d = b ``` """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("if_mover_dependent_branches")) + sdfg = dace.SDFG(util.unique_name("if_mover_dependent_branches")) state = sdfg.add_state(is_start_block=True) # Inputs @@ -625,7 +625,7 @@ def test_if_mover_dependent_branch_2(): d = b1 ``` """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("if_mover_dependent_branches_2")) + sdfg = dace.SDFG(util.unique_name("if_mover_dependent_branches_2")) state = sdfg.add_state(is_start_block=True) # Inputs @@ -725,7 +725,7 @@ def test_if_mover_dependent_branch_3(): Very similar test to `test_if_mover_dependent_branch_1()`, but the common data is an AccessNode outside the Map. """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("if_mover_dependent_branches")) + sdfg = dace.SDFG(util.unique_name("if_mover_dependent_branches")) state = sdfg.add_state(is_start_block=True) gnames = ["a", "b", "c", "d", "cond"] @@ -831,7 +831,7 @@ def test_if_mover_dependent_branch_4(): f = s ``` """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("if_mover_dependent_branches")) + sdfg = dace.SDFG(util.unique_name("if_mover_dependent_branches")) state = sdfg.add_state(is_start_block=True) # Inputs @@ -1010,7 +1010,7 @@ def test_if_mover_dependent_branch_5(): f = s ``` """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("if_mover_dependent_branches")) + sdfg = dace.SDFG(util.unique_name("if_mover_dependent_branches")) state = sdfg.add_state(is_start_block=True) # Inputs @@ -1199,7 +1199,7 @@ def test_if_mover_dependent_branch_6(): e = e1 ``` """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("if_mover_")) + sdfg = dace.SDFG(util.unique_name("if_mover_")) state = sdfg.add_state(is_start_block=True) gnames = ["a", "b", "c", "d", "e", "cond"] @@ -1353,7 +1353,7 @@ def test_if_mover_no_ops(): ``` I.e. there is no gain from moving something inside the body. """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("if_mover_no_ops")) + sdfg = dace.SDFG(util.unique_name("if_mover_no_ops")) state = sdfg.add_state(is_start_block=True) # Inputs @@ -1413,7 +1413,7 @@ def test_if_mover_one_branch_is_nothing(): I.e. in one case something can be moved in but there is nothing to move for the other branch. """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("if_mover_one_branch_is_nothing")) + sdfg = dace.SDFG(util.unique_name("if_mover_one_branch_is_nothing")) state = sdfg.add_state(is_start_block=True) # Inputs @@ -1503,7 +1503,7 @@ def test_if_mover_chain(): e = aa if cc else bb ``` """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("if_mover_chain_of_blocks")) + sdfg = dace.SDFG(util.unique_name("if_mover_chain_of_blocks")) state = sdfg.add_state(is_start_block=True) # Inputs @@ -1617,7 +1617,7 @@ def test_if_mover_chain(): def test_if_mover_symbolic_tasklet(): - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("if_mover_symbols_in_tasklets")) + sdfg = dace.SDFG(util.unique_name("if_mover_symbols_in_tasklets")) state = sdfg.add_state(is_start_block=True) for i in [1, 2]: @@ -1732,7 +1732,7 @@ def test_if_mover_access_node_between(): e = aa if cc else bb ``` """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("if_mover_chain_of_blocks")) + sdfg = dace.SDFG(util.unique_name("if_mover_chain_of_blocks")) state = sdfg.add_state(is_start_block=True) # Inputs @@ -1878,7 +1878,7 @@ def test_if_mover_symbol_aliasing(): however, with different meanings. Thus the relocation will lead to invalid behaviour and should be rejected. """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("if_mover_symbol_alias")) + sdfg = dace.SDFG(util.unique_name("if_mover_symbol_alias")) state = sdfg.add_state(is_start_block=True) scalar_names = ["cond", "a1", "b2"] @@ -2001,7 +2001,7 @@ def _make_nested_sdfg(cond_name: str, iter_name: str) -> dace.SDFG: ) fstate.add_edge(f_tasklet, "__out", fstate.add_access("out"), None, dace.Memlet("out[0]")) - if_region = dace.sdfg.state.ConditionalBlock(gtx_transformations.utils.unique_name("if")) + if_region = dace.sdfg.state.ConditionalBlock(util.unique_name("if")) sdfg.add_node(if_region, is_start_block=True) if_region.add_branch(dace.sdfg.state.CodeBlock(cond_name), then_body) if_region.add_branch(dace.sdfg.state.CodeBlock(f"not {cond_name}"), else_body) @@ -2014,7 +2014,7 @@ def _make_outer_sdfg( iter_name: str, outer_slice_variable: bool, ) -> tuple[dace.SDFG, dace.SDFGState, dace_nodes.NestedSDFG]: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("if_mover_slicing")) + sdfg = dace.SDFG(util.unique_name("if_mover_slicing")) state = sdfg.add_state(is_start_block=True) # Inputs @@ -2175,7 +2175,7 @@ def test_if_mover_symbol_clashes_with_inner_data(): must detect this conflict via ``_check_for_data_and_symbol_conflicts`` and refuse to apply. """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("symbol_data_clash")) + sdfg = dace.SDFG(util.unique_name("symbol_data_clash")) state = sdfg.add_state(is_start_block=True) # `my_var` is a symbol in the outer SDFG, not a data container. @@ -2301,7 +2301,7 @@ def test_if_mover_two_accessnodes_same_outer_data(): ``elif outer_data in fully_mapped_in_data`` branch and hits ``assert (outer_data, branch_state) not in rename_map`` → crash. """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("two_accessnodes_same_outer_data")) + sdfg = dace.SDFG(util.unique_name("two_accessnodes_same_outer_data")) state = sdfg.add_state(is_start_block=True) # Outer arrays diff --git a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_move_tasklet_into_map.py b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_move_tasklet_into_map.py index 51a577e467..a42f9f24f2 100644 --- a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_move_tasklet_into_map.py +++ b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_move_tasklet_into_map.py @@ -11,9 +11,10 @@ dace = pytest.importorskip("dace") -from dace.sdfg import nodes as dace_nodes, propagation as dace_propagation +from dace.sdfg import nodes as dace_nodes from dace.transformation import dataflow as dace_dataflow +from gt4py.next import utils as gtx_utils from gt4py.next.program_processors.runners.dace import ( transformations as gtx_transformations, ) @@ -26,7 +27,7 @@ def _make_movable_tasklet( ) -> tuple[ dace.SDFG, dace.SDFGState, dace_nodes.Tasklet, dace_nodes.AccessNode, dace_nodes.MapEntry ]: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("gpu_promotable_sdfg")) + sdfg = dace.SDFG(util.unique_name("gpu_promotable_sdfg")) state = sdfg.add_state("state", is_start_block=True) sdfg.add_scalar("outer_scalar", dtype=dace.float64, transient=True) @@ -60,13 +61,13 @@ def _make_movable_tasklet( return sdfg, state, outer_tasklet, outer_scalar, me -def test_move_tasklet_inside_trivial_memlet_tree(): +def test_move_tasklet_inside_trivial_memlet_tree(uids: gtx_utils.IDGeneratorPool): sdfg, state, outer_tasklet, outer_scalar, me = _make_movable_tasklet( outer_tasklet_code="1.2", ) count = sdfg.apply_transformations_repeated( - gtx_transformations.GT4PyMoveTaskletIntoMap, + gtx_transformations.GT4PyMoveTaskletIntoMap(uids=uids), validate_all=True, ) assert count == 1 @@ -79,7 +80,7 @@ def test_move_tasklet_inside_trivial_memlet_tree(): assert np.allclose(B, ref) -def test_move_tasklet_inside_non_trivial_memlet_tree(): +def test_move_tasklet_inside_non_trivial_memlet_tree(uids: gtx_utils.IDGeneratorPool): sdfg, state, outer_tasklet, outer_scalar, me = _make_movable_tasklet( outer_tasklet_code="1.2", ) @@ -89,7 +90,7 @@ def test_move_tasklet_inside_non_trivial_memlet_tree(): me = None count = sdfg.apply_transformations_repeated( - gtx_transformations.GT4PyMoveTaskletIntoMap, + gtx_transformations.GT4PyMoveTaskletIntoMap(uids=uids), validate_all=True, ) assert count == 1 @@ -102,7 +103,7 @@ def test_move_tasklet_inside_non_trivial_memlet_tree(): assert np.allclose(B, ref) -def test_move_tasklet_inside_two_inner_connector(): +def test_move_tasklet_inside_two_inner_connector(uids: gtx_utils.IDGeneratorPool): sdfg, state, outer_tasklet, outer_scalar, me = _make_movable_tasklet( outer_tasklet_code="32.2", ) @@ -121,7 +122,7 @@ def test_move_tasklet_inside_two_inner_connector(): mapped_tasklet.code.as_string = "__out = __in0 + __in1 + __in2" count = sdfg.apply_transformations_repeated( - gtx_transformations.GT4PyMoveTaskletIntoMap, + gtx_transformations.GT4PyMoveTaskletIntoMap(uids=uids), validate_all=True, ) assert count == 1 @@ -134,7 +135,7 @@ def test_move_tasklet_inside_two_inner_connector(): assert np.allclose(B, ref) -def test_move_tasklet_inside_outer_scalar_used_outside(): +def test_move_tasklet_inside_outer_scalar_used_outside(uids: gtx_utils.IDGeneratorPool): sdfg, state, outer_tasklet, outer_scalar, me = _make_movable_tasklet( outer_tasklet_code="22.6", ) @@ -142,7 +143,7 @@ def test_move_tasklet_inside_outer_scalar_used_outside(): state.add_edge(outer_scalar, None, state.add_access("C"), None, dace.Memlet("C[0]")) count = sdfg.apply_transformations_repeated( - gtx_transformations.GT4PyMoveTaskletIntoMap, + gtx_transformations.GT4PyMoveTaskletIntoMap(uids=uids), validate_all=True, ) assert count == 1 diff --git a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_multi_state_global_self_copy_elimination.py b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_multi_state_global_self_copy_elimination.py index 30dd8de029..fc07d3a831 100644 --- a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_multi_state_global_self_copy_elimination.py +++ b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_multi_state_global_self_copy_elimination.py @@ -32,7 +32,7 @@ def apply_distributed_self_copy_elimination( def _make_not_apply_because_of_write_to_g_sdfg() -> dace.SDFG: """This SDFG is not eligible, because there is a write to `G`.""" - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("not_apply_because_of_write_to_g_sdfg")) + sdfg = dace.SDFG(util.unique_name("not_apply_because_of_write_to_g_sdfg")) # This is the `G` array. sdfg.add_array(name="a", shape=(10,), dtype=dace.float64, transient=False) @@ -83,7 +83,7 @@ def _make_eligible_sdfg_1() -> dace.SDFG: The main difference is that there is no mutating write to `a` and thus the transformation applies. """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("_make_eligible_sdfg_1")) + sdfg = dace.SDFG(util.unique_name("_make_eligible_sdfg_1")) # This is the `G` array. sdfg.add_array(name="a", shape=(10,), dtype=dace.float64, transient=False) @@ -126,7 +126,7 @@ def _make_eligible_sdfg_1() -> dace.SDFG: def _make_multiple_temporaries_sdfg1() -> dace.SDFG: """Generates an SDFG in which `G` is saved into different temporaries.""" - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("multiple_temporaries")) + sdfg = dace.SDFG(util.unique_name("multiple_temporaries")) # This is the `G` array. sdfg.add_array(name="a", shape=(10,), dtype=dace.float64, transient=False) @@ -170,7 +170,7 @@ def _make_multiple_temporaries_sdfg2() -> dace.SDFG: generated by `_make_multiple_temporaries_sdfg()` is that the temporaries are used sequentially. """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("multiple_temporaries_sequential")) + sdfg = dace.SDFG(util.unique_name("multiple_temporaries_sequential")) # This is the `G` array. sdfg.add_array(name="a", shape=(10,), dtype=dace.float64, transient=False) @@ -281,7 +281,7 @@ def _make_non_eligible_because_of_pseudo_temporary() -> dace.SDFG: Note that in this particular case it would be possible, but we do not support it. """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("multiple_temporaries_sequential")) + sdfg = dace.SDFG(util.unique_name("multiple_temporaries_sequential")) # This is the `G` array. sdfg.add_array(name="a", shape=(10,), dtype=dace.float64, transient=False) @@ -321,7 +321,7 @@ def _make_wb_single_state_sdfg() -> dace.SDFG: This pattern is handled by the `SingleStateGlobalSelfCopyElimination` transformation. """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("single_state_write_back_sdfg")) + sdfg = dace.SDFG(util.unique_name("single_state_write_back_sdfg")) sdfg.add_array("g", shape=(10,), dtype=dace.float64, transient=False) sdfg.add_array("t", shape=(10,), dtype=dace.float64, transient=True) @@ -351,7 +351,7 @@ def _make_wb_single_state_sdfg() -> dace.SDFG: def _make_non_eligible_sdfg_with_branches(): """Creates an SDFG with two different definitions of `T`.""" - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("non_eligible_sdfg_with_branches_sdfg")) + sdfg = dace.SDFG(util.unique_name("non_eligible_sdfg_with_branches_sdfg")) # This is the `G` array, it is also used as output. sdfg.add_array("a", shape=(10,), dtype=dace.float64, transient=False) @@ -400,7 +400,7 @@ def _make_write_into_global_at_t_definition() -> tuple[ This SDFG is different from `_make_not_apply_because_of_write_to_g_sdfg` as the write happens before we define `t`. """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("write_into_global_at_t_definition")) + sdfg = dace.SDFG(util.unique_name("write_into_global_at_t_definition")) state1 = sdfg.add_state(is_start_block=True) state2 = sdfg.add_state_after(state1) diff --git a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_multiple_copies_global.py b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_multiple_copies_global.py index 963b3321bc..b763393253 100644 --- a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_multiple_copies_global.py +++ b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_multiple_copies_global.py @@ -22,7 +22,7 @@ def test_complex_copies_global_access_node(): N = 64 K = 80 - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("vertically_implicit_solver_like_sdfg")) + sdfg = dace.SDFG(util.unique_name("vertically_implicit_solver_like_sdfg")) A, _ = sdfg.add_array("A", [N, K + 1], dtype=dace.float64) B, _ = sdfg.add_array("B", [N, K + 1], dtype=dace.float64) tmp0, _ = sdfg.add_temp_transient([N], dtype=dace.float64) diff --git a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_remove_point_view.py b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_remove_point_view.py index d86529f79d..04312fb7c5 100644 --- a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_remove_point_view.py +++ b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_remove_point_view.py @@ -25,7 +25,7 @@ def _make_sdfg_with_map_with_view( use_array_as_temp: bool = False, ) -> dace.SDFG: shape = (N, N) - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("simple_map_with_view")) + sdfg = dace.SDFG(util.unique_name("simple_map_with_view")) state = sdfg.add_state(is_start_block=True) for name in ["a", "out"]: diff --git a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_remove_scalar_copies.py b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_remove_scalar_copies.py index c7616541db..130b70589c 100644 --- a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_remove_scalar_copies.py +++ b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_remove_scalar_copies.py @@ -24,7 +24,7 @@ def _make_map_with_scalar_copies() -> tuple[ dace.SDFG, dace.SDFGState, dace_nodes.MapEntry, dace_nodes.MapExit ]: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("scalar_elimination")) + sdfg = dace.SDFG(util.unique_name("scalar_elimination")) state = sdfg.add_state(is_start_block=True) sdfg.add_array( diff --git a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_single_state_global_self_copy_elimination.py b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_single_state_global_self_copy_elimination.py index 76e99a4678..306f05454e 100644 --- a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_single_state_global_self_copy_elimination.py +++ b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_single_state_global_self_copy_elimination.py @@ -25,7 +25,7 @@ def _make_self_copy_sdfg() -> tuple[dace.SDFG, dace.SDFGState]: """Generates an SDFG that contains the self copying pattern.""" - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("self_copy_sdfg")) + sdfg = dace.SDFG(util.unique_name("self_copy_sdfg")) state = sdfg.add_state(is_start_block=True) for name in "GT": @@ -46,7 +46,7 @@ def _make_self_copy_sdfg() -> tuple[dace.SDFG, dace.SDFGState]: def _make_direct_self_copy_elimination_used_sdfg() -> dace.SDFG: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("direct_self_copy_elimination_used")) + sdfg = dace.SDFG(util.unique_name("direct_self_copy_elimination_used")) state = sdfg.add_state(is_start_block=True) for name in "ABCG": @@ -88,7 +88,7 @@ def _make_self_copy_sdfg_with_multiple_paths() -> tuple[ `SingleStateGlobalDirectSelfCopyElimination` transformation can not handle this case, but its split node can handle it. """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("self_copy_sdfg_with_multiple_paths")) + sdfg = dace.SDFG(util.unique_name("self_copy_sdfg_with_multiple_paths")) state = sdfg.add_state(is_start_block=True) for name in "GT": @@ -132,9 +132,7 @@ def _make_concat_where_like( j_idx = 0 j_range = "1:10" - sdfg = dace.SDFG( - gtx_transformations.utils.unique_name(f"self_copy_sdfg_concat_where_like_{j_desc}_level") - ) + sdfg = dace.SDFG(util.unique_name(f"self_copy_sdfg_concat_where_like_{j_desc}_level")) state = sdfg.add_state(is_start_block=True) sdfg.add_array( @@ -217,11 +215,7 @@ def _make_concat_where_like_with_silent_write_to_g1( dace_nodes.AccessNode, dace_nodes.AccessNode, ]: - sdfg = dace.SDFG( - gtx_transformations.utils.unique_name( - f"self_copy_sdfg_concat_where_like_multiple_writes_to_g1" - ) - ) + sdfg = dace.SDFG(util.unique_name(f"self_copy_sdfg_concat_where_like_multiple_writes_to_g1")) state = sdfg.add_state(is_start_block=True) sdfg.add_array( @@ -313,9 +307,7 @@ def _make_concat_where_like_41_to_60( dace_nodes.AccessNode, dace_nodes.AccessNode, ]: - sdfg = dace.SDFG( - gtx_transformations.utils.unique_name(f"self_copy_sdfg_concat_where_like_41_to_60") - ) + sdfg = dace.SDFG(util.unique_name(f"self_copy_sdfg_concat_where_like_41_to_60")) state = sdfg.add_state(is_start_block=True) sdfg.add_array( @@ -451,7 +443,7 @@ def _make_concat_where_like_not_possible() -> tuple[ """Because the "Bulk Map" writes more into `tmp` than is written back the transformation is not applicable. """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name(f"self_copy_too_big_bulk_write")) + sdfg = dace.SDFG(util.unique_name(f"self_copy_too_big_bulk_write")) state = sdfg.add_state(is_start_block=True) sdfg.add_array( @@ -507,7 +499,7 @@ def _make_multi_t_patch_sdfg() -> tuple[ uninitialized because it is not read. """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name(f"multi_t_patch_description_sdfg")) + sdfg = dace.SDFG(util.unique_name(f"multi_t_patch_description_sdfg")) state = sdfg.add_state(is_start_block=True) for name in "gabt": @@ -590,7 +582,7 @@ def _make_not_everything_is_written_back( in fact running `SplitAccessNode` would do the job. """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name(f"not_everything_is_written_back")) + sdfg = dace.SDFG(util.unique_name(f"not_everything_is_written_back")) state = sdfg.add_state(is_start_block=True) consumer_shape = (10,) if consume_all_of_t else (6,) @@ -653,7 +645,7 @@ def _make_not_everything_is_written_back( def _make_write_write_conflict( conflict_at_t: bool, ) -> dace.SDFG: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name(f"write_write_conflict_sdfg")) + sdfg = dace.SDFG(util.unique_name(f"write_write_conflict_sdfg")) state = sdfg.add_state(is_start_block=True) for name in "gto": @@ -725,7 +717,7 @@ def _make_write_write_conflict( def _make_read_write_conflict() -> dace.SDFG: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name(f"write_write_conflict_sdfg")) + sdfg = dace.SDFG(util.unique_name(f"write_write_conflict_sdfg")) state = sdfg.add_state(is_start_block=True) for name in "gtom": @@ -904,7 +896,7 @@ def test_global_self_copy_elimination_tmp_downstream(): def test_direct_global_self_copy_simple(): - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("simple_direct_self_copy")) + sdfg = dace.SDFG(util.unique_name("simple_direct_self_copy")) state = sdfg.add_state(is_start_block=True) sdfg.add_array( diff --git a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_split_access_node.py b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_split_access_node.py index 1bfa02cfe1..be7ed5405d 100644 --- a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_split_access_node.py +++ b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_split_access_node.py @@ -64,7 +64,7 @@ def _perform_test( def test_map_producer_ac_consumer(): """The data is generated by a Map and then consumed by an AccessNode.""" - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("map_producer_ac_consumer")) + sdfg = dace.SDFG(util.unique_name("map_producer_ac_consumer")) state = sdfg.add_state(is_start_block=True) for name in "abtcd": @@ -96,7 +96,7 @@ def test_map_producer_ac_consumer(): def test_map_producer_map_consumer(): """The data is generated by a Map and then consumed by another Map.""" - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("map_producer_map_consumer")) + sdfg = dace.SDFG(util.unique_name("map_producer_map_consumer")) state = sdfg.add_state(is_start_block=True) for name in "abtcd": @@ -135,7 +135,7 @@ def test_map_producer_map_consumer(): def test_ac_producer_ac_consumer(): - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("ac_producer_ac_consumer")) + sdfg = dace.SDFG(util.unique_name("ac_producer_ac_consumer")) state = sdfg.add_state(is_start_block=True) for name in "abtcd": @@ -159,7 +159,7 @@ def test_ac_producer_ac_consumer(): def test_ac_producer_map_consumer(): - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("ac_producer_map_consumer")) + sdfg = dace.SDFG(util.unique_name("ac_producer_map_consumer")) state = sdfg.add_state(is_start_block=True) for name in "abtcd": @@ -193,9 +193,7 @@ def test_simple_splitable_ac_source_not_full_consume(): """Similar to `test_simple_splitable_ac_source_full_consume`, but one consumer does not fully consumer what is produced. """ - sdfg = dace.SDFG( - gtx_transformations.utils.unique_name("simple_splitable_ac_source_not_full_consume") - ) + sdfg = dace.SDFG(util.unique_name("simple_splitable_ac_source_not_full_consume")) state = sdfg.add_state(is_start_block=True) for name in "abtcde": @@ -223,9 +221,7 @@ def test_simple_splitable_ac_source_multiple_consumer(): """Similar to `test_simple_splitable_ac_source_not_full_consume`, but there are multiple consumer, per producer. """ - sdfg = dace.SDFG( - gtx_transformations.utils.unique_name("simple_splitable_ac_source_multiple_consumer") - ) + sdfg = dace.SDFG(util.unique_name("simple_splitable_ac_source_multiple_consumer")) state = sdfg.add_state(is_start_block=True) for name in "abtcde": @@ -263,9 +259,7 @@ def _make_transient_producer_sdfg( depending on the value of `partial_read`. """ sdfg = dace.SDFG( - gtx_transformations.utils.unique_name( - "partial_ac_read" + ("_partial_read" if partial_read else "_full_read") - ) + util.unique_name("partial_ac_read" + ("_partial_read" if partial_read else "_full_read")) ) state = sdfg.add_state(is_start_block=True) for name in ["a", "b", "c", "d", "t1", "t2"]: @@ -308,7 +302,7 @@ def test_transient_producer_partial_read(): def test_overlapping_consume_ac_source(): """There are 2 producers, but only one consumer that needs both producers.""" - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("overlapping_consume_ac_source")) + sdfg = dace.SDFG(util.unique_name("overlapping_consume_ac_source")) state = sdfg.add_state(is_start_block=True) for name in "abtc": @@ -339,7 +333,7 @@ def _make_map_producer_multiple_consumer( `partial_read` it will either read the full data for only parts of it. """ sdfg = dace.SDFG( - gtx_transformations.utils.unique_name( + util.unique_name( "map_producer_map_consumer" + ("_partial_read" if partial_read else "_full_read") ) ) @@ -398,7 +392,7 @@ def test_map_producer_multi_consumer_partialread(): def test_same_producer(): - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("same_producer")) + sdfg = dace.SDFG(util.unique_name("same_producer")) state = sdfg.add_state(is_start_block=True) for name in "abt": @@ -460,7 +454,7 @@ def test_map_producer_complex_map_consumer(): b[15:20] -> e[15:20] c[20:25] -> e[20:25] """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("map_producer_ac_consumer")) + sdfg = dace.SDFG(util.unique_name("map_producer_ac_consumer")) state = sdfg.add_state(is_start_block=True) for name in "abtcde": @@ -537,7 +531,7 @@ def test_map_producer_complex_map_consumer(): def test_map_producer_map_consumer_complex(): """The data is generated by a Map and then consumed by another Map.""" - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("map_producer_map_consumer")) + sdfg = dace.SDFG(util.unique_name("map_producer_map_consumer")) state = sdfg.add_state(is_start_block=True) for name in "abtcde": @@ -629,7 +623,7 @@ def test_map_producer_ac_consumer_complex(): " nodes that have as inputs Maps whose outputs are assigned to AccessNodes." ) - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("map_producer_map_consumer")) + sdfg = dace.SDFG(util.unique_name("map_producer_map_consumer")) state = sdfg.add_state(is_start_block=True) for name in "abtcde": @@ -699,7 +693,7 @@ def test_ac_producer_complex_map_consumer(): " nodes that have AccessNodes as input and Maps as outputs." ) - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("map_producer_ac_consumer")) + sdfg = dace.SDFG(util.unique_name("map_producer_ac_consumer")) state = sdfg.add_state(is_start_block=True) for name in "abtcde": @@ -766,7 +760,7 @@ def test_ac_producer_complex_ac_consumer(): b[33:38] -> e[22:27] c[14:19] -> e[27:32] """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("ac_producer_complex_ac_consumer")) + sdfg = dace.SDFG(util.unique_name("ac_producer_complex_ac_consumer")) state = sdfg.add_state(is_start_block=True) for name in "abtcde": @@ -823,7 +817,7 @@ def test_ac_producer_ac_consumer_complex(): b[28:33] -> d[27:32] b[33:38] -> e[34:39] """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("ac_producer_ac_consumer_complex")) + sdfg = dace.SDFG(util.unique_name("ac_producer_ac_consumer_complex")) state = sdfg.add_state(is_start_block=True) for name in "abtcde": @@ -874,7 +868,7 @@ def test_unused_partial_read_from_inout_node(): a[0:5] -> c[0:5] t[5:10] -> c[5:10] """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("full_write_from_global_to_split_node")) + sdfg = dace.SDFG(util.unique_name("full_write_from_global_to_split_node")) for data in "abc": sdfg.add_array(data, [10], dace.float64) t, _ = sdfg.add_temp_transient([10], dace.float64) diff --git a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_split_memlet.py b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_split_memlet.py index 9dda69f253..e5d5532ade 100644 --- a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_split_memlet.py +++ b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_split_memlet.py @@ -25,9 +25,7 @@ def _make_split_edge_two_ac_producer_one_ac_consumer_1d_sdfg() -> tuple[dace.SDFG, dace.SDFGState]: - sdfg = dace.SDFG( - gtx_transformations.utils.unique_name("split_edge_two_ac_producer_one_ac_consumer_1d") - ) + sdfg = dace.SDFG(util.unique_name("split_edge_two_ac_producer_one_ac_consumer_1d")) state = sdfg.add_state(is_start_block=True) sdfg.add_array("src1", shape=(10,), dtype=dace.float64, transient=False) @@ -81,7 +79,7 @@ def _make_split_edge_mock_apply_diffusion_to_w_sdfg() -> tuple[ ]: # Test is roughly equivalent to what we see in `apply_diffusion_to_w` # Although instead of Maps we sometimes use direct edges. - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("split_edge_mock_apply_diffusion_to_w")) + sdfg = dace.SDFG(util.unique_name("split_edge_mock_apply_diffusion_to_w")) state = sdfg.add_state(is_start_block=True) diff --git a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_splitting_tools.py b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_splitting_tools.py index 06e2caf187..d8373593c5 100644 --- a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_splitting_tools.py +++ b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_splitting_tools.py @@ -37,7 +37,7 @@ def _make_distributed_split_sdfg() -> tuple[ dace.SDFGState, dace_nodes.AccessNode, ]: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("distributed_split_sdfg")) + sdfg = dace.SDFG(util.unique_name("distributed_split_sdfg")) state = sdfg.add_state(is_start_block=True) state2 = sdfg.add_state_after(state) @@ -115,7 +115,7 @@ def test_distributed_split(): def _make_split_node_simple_sdfg() -> tuple[ dace.SDFG, dace.SDFGState, dace_nodes.AccessNode, dace_nodes.MapExit, dace_nodes.MapExit ]: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("single_state_split")) + sdfg = dace.SDFG(util.unique_name("single_state_split")) state = sdfg.add_state(is_start_block=True) for name in "abt": @@ -201,7 +201,7 @@ def test_simple_node_split(): def _make_split_edge_sdfg() -> tuple[ dace.SDFG, dace.SDFGState, dace_nodes.AccessNode, dace_nodes.AccessNode ]: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("split_edge")) + sdfg = dace.SDFG(util.unique_name("split_edge")) state = sdfg.add_state(is_start_block=True) for name in "abt": @@ -281,7 +281,7 @@ def test_split_edge(): def test_split_edge_2d(): - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("split_edge_2d")) + sdfg = dace.SDFG(util.unique_name("split_edge_2d")) state = sdfg.add_state(is_start_block=True) for name in "ab": @@ -422,7 +422,7 @@ def test_subset_merging_stability(): def _make_sdfg_for_deterministic_splitting() -> tuple[ dace.SDFG, dace.SDFGState, dace_nodes.AccessNode ]: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("deterministic_splitter")) + sdfg = dace.SDFG(util.unique_name("deterministic_splitter")) state = sdfg.add_state(is_start_block=True) for name in "abtcd": diff --git a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_state_fusion.py b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_state_fusion.py index d5734f9f27..653a36bad9 100644 --- a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_state_fusion.py +++ b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_state_fusion.py @@ -25,7 +25,7 @@ def _make_simple_two_state_sdfg() -> tuple[dace.SDFG, dace.SDFGState, dace.SDFGState]: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("simple_linear_states")) + sdfg = dace.SDFG(util.unique_name("simple_linear_states")) state1 = sdfg.add_state(is_start_block=True) state2 = sdfg.add_state_after(state1) @@ -71,7 +71,7 @@ def _make_simple_two_state_sdfg() -> tuple[dace.SDFG, dace.SDFGState, dace.SDFGS def _make_global_in_both_read_and_write() -> tuple[dace.SDFG, dace.SDFGState, dace.SDFGState]: """The first state contains a read to a global and the second contains a write to the global.""" - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("global_in_both_states_read_and_write")) + sdfg = dace.SDFG(util.unique_name("global_in_both_states_read_and_write")) state1 = sdfg.add_state(is_start_block=True) state2 = sdfg.add_state_after(state1) @@ -106,7 +106,7 @@ def _make_global_in_both_read_and_write() -> tuple[dace.SDFG, dace.SDFGState, da def _make_global_both_state_read() -> tuple[dace.SDFG, dace.SDFGState, dace.SDFGState]: """In both states the same global is read.""" - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("global_read_in_the_same_state")) + sdfg = dace.SDFG(util.unique_name("global_read_in_the_same_state")) state1 = sdfg.add_state(is_start_block=True) state2 = sdfg.add_state_after(state1) @@ -140,7 +140,7 @@ def _make_global_both_state_read() -> tuple[dace.SDFG, dace.SDFGState, dace.SDFG def _make_global_both_state_write() -> tuple[dace.SDFG, dace.SDFGState, dace.SDFGState]: """In both states the same global is written.""" - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("global_write_in_the_same_state")) + sdfg = dace.SDFG(util.unique_name("global_write_in_the_same_state")) state1 = sdfg.add_state(is_start_block=True) state2 = sdfg.add_state_after(state1) @@ -176,9 +176,7 @@ def _make_empty_state( first_state_empty: bool, ) -> tuple[dace.SDFG, dace.SDFGState, dace.SDFGState]: sdfg = dace.SDFG( - gtx_transformations.utils.unique_name( - "global_" + ("first" if first_state_empty else "second") + "_state_empty" - ) + util.unique_name("global_" + ("first" if first_state_empty else "second") + "_state_empty") ) state1 = sdfg.add_state(is_start_block=True) state2 = sdfg.add_state_after(state1) @@ -206,7 +204,7 @@ def _make_empty_state( def _make_global_merge_1() -> dace.SDFG: """The first state writes to a global while the second state reads and writes to it.""" - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("global_merge_1")) + sdfg = dace.SDFG(util.unique_name("global_merge_1")) state1 = sdfg.add_state(is_start_block=True) state2 = sdfg.add_state_after(state1) @@ -239,7 +237,7 @@ def _make_global_merge_1() -> dace.SDFG: def _make_global_merge_2() -> dace.SDFG: """In both states the global data is read and written to.""" - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("global_merge_2")) + sdfg = dace.SDFG(util.unique_name("global_merge_2")) state1 = sdfg.add_state(is_start_block=True) state2 = sdfg.add_state_after(state1) @@ -271,7 +269,7 @@ def _make_global_merge_2() -> dace.SDFG: def _make_swapping_sdfg() -> dace.SDFG: """Makes an SDFG that implements `x, y = y, x` with Memlets.""" - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("swapping_sdfg")) + sdfg = dace.SDFG(util.unique_name("swapping_sdfg")) state1 = sdfg.add_state(is_start_block=True) state2 = sdfg.add_state_after(state1) @@ -301,7 +299,7 @@ def _make_swapping_sdfg() -> dace.SDFG: def _make_non_concurrent_sdfg() -> tuple[dace.SDFG, dace.SDFGState, dace.SDFGState]: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("non_concurrent_sdfg")) + sdfg = dace.SDFG(util.unique_name("non_concurrent_sdfg")) state1 = sdfg.add_state(is_start_block=True) state2 = sdfg.add_state_after(state1) @@ -347,7 +345,7 @@ def _make_non_concurrent_sdfg() -> tuple[dace.SDFG, dace.SDFGState, dace.SDFGSta def _make_double_producer_sdfg() -> tuple[dace.SDFG, dace.SDFGState, dace.SDFGState]: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("double_producer_sdfg")) + sdfg = dace.SDFG(util.unique_name("double_producer_sdfg")) state1 = sdfg.add_state(is_start_block=True) state2 = sdfg.add_state_after(state1) @@ -396,7 +394,7 @@ def _make_double_producer_sdfg() -> tuple[dace.SDFG, dace.SDFGState, dace.SDFGSt def _make_double_consumer_sdfg() -> tuple[dace.SDFG, dace.SDFGState, dace.SDFGState]: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("double_consumer_sdfg")) + sdfg = dace.SDFG(util.unique_name("double_consumer_sdfg")) state1 = sdfg.add_state(is_start_block=True) state2 = sdfg.add_state_after(state1) @@ -470,7 +468,7 @@ def _make_double_consumer_sdfg() -> tuple[dace.SDFG, dace.SDFGState, dace.SDFGSt def _make_hidden_double_producer_sdfg() -> tuple[dace.SDFG, dace.SDFGState, dace.SDFGState]: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("hidden_double_producer_sdfg")) + sdfg = dace.SDFG(util.unique_name("hidden_double_producer_sdfg")) state1 = sdfg.add_state(is_start_block=True) state2 = sdfg.add_state_after(state1) @@ -626,7 +624,7 @@ def test_empty_second_state(): def test_both_states_are_empty(): - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("full_empty_sdfg")) + sdfg = dace.SDFG(util.unique_name("full_empty_sdfg")) state1 = sdfg.add_state(is_start_block=True) state2 = sdfg.add_state_after(state1) assert util.count_nodes(sdfg, dace_nodes.AccessNode) == 0 diff --git a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_strides.py b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_strides.py index 2258a0931c..89a084d764 100644 --- a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_strides.py +++ b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_strides.py @@ -23,7 +23,7 @@ def _make_strides_propagation_level3_sdfg() -> dace.SDFG: """Generates the level 3 SDFG (nested-nested) SDFG for `test_strides_propagation()`.""" - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("level3")) + sdfg = dace.SDFG(util.unique_name("level3")) state = sdfg.add_state(is_start_block=True) names = ["a3", "c3"] @@ -56,7 +56,7 @@ def _make_strides_propagation_level2_sdfg() -> tuple[dace.SDFG, dace_nodes.Neste The function returns the level 2 SDFG and the NestedSDFG node that contains the level 3 SDFG. """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("level2")) + sdfg = dace.SDFG(util.unique_name("level2")) state = sdfg.add_state(is_start_block=True) names = ["a2", "a2_alias", "b2", "c2"] @@ -123,7 +123,7 @@ def _make_strides_propagation_level1_sdfg() -> tuple[ - The NestedSDFG node that contains the lebel 3 SDFG (member of the level 2 SDFG). """ - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("level1")) + sdfg = dace.SDFG(util.unique_name("level1")) state = sdfg.add_state(is_start_block=True) names = ["a1", "b1", "c1"] @@ -236,9 +236,7 @@ def test_strides_propagation(): def _make_strides_propagation_dependent_symbol_nsdfg() -> dace.SDFG: - sdfg = dace.SDFG( - gtx_transformations.utils.unique_name("strides_propagation_dependent_symbol_nsdfg") - ) + sdfg = dace.SDFG(util.unique_name("strides_propagation_dependent_symbol_nsdfg")) state = sdfg.add_state(is_start_block=True) array_names = ["a2", "b2"] @@ -266,9 +264,7 @@ def _make_strides_propagation_dependent_symbol_nsdfg() -> dace.SDFG: def _make_strides_propagation_dependent_symbol_sdfg() -> tuple[dace.SDFG, dace_nodes.NestedSDFG]: - sdfg_level1 = dace.SDFG( - gtx_transformations.utils.unique_name("strides_propagation_dependent_symbol_sdfg") - ) + sdfg_level1 = dace.SDFG(util.unique_name("strides_propagation_dependent_symbol_sdfg")) state = sdfg_level1.add_state(is_start_block=True) array_names = ["a1", "b1"] @@ -347,9 +343,7 @@ def test_strides_propagation_symbolic_expression(): def _make_strides_propagation_shared_symbols_nsdfg() -> dace.SDFG: - sdfg = dace.SDFG( - gtx_transformations.utils.unique_name("strides_propagation_shared_symbols_nsdfg") - ) + sdfg = dace.SDFG(util.unique_name("strides_propagation_shared_symbols_nsdfg")) state = sdfg.add_state(is_start_block=True) # NOTE: Both arrays have the same symbols used for strides. @@ -383,9 +377,7 @@ def _make_strides_propagation_shared_symbols_nsdfg() -> dace.SDFG: def _make_strides_propagation_shared_symbols_sdfg() -> tuple[dace.SDFG, dace_nodes.NestedSDFG]: - sdfg_level1 = dace.SDFG( - gtx_transformations.utils.unique_name("strides_propagation_shared_symbols_sdfg") - ) + sdfg_level1 = dace.SDFG(util.unique_name("strides_propagation_shared_symbols_sdfg")) state = sdfg_level1.add_state(is_start_block=True) # NOTE: Both arrays use the same symbols as strides. @@ -477,9 +469,7 @@ def ref(a1, b1): def _make_strides_propagation_stride_1_nsdfg() -> dace.SDFG: - sdfg_level1 = dace.SDFG( - gtx_transformations.utils.unique_name("strides_propagation_stride_1_nsdfg") - ) + sdfg_level1 = dace.SDFG(util.unique_name("strides_propagation_stride_1_nsdfg")) state = sdfg_level1.add_state(is_start_block=True) a_stride_sym = dace.symbol("a_stride", dtype=dace.uint32) @@ -508,7 +498,7 @@ def _make_strides_propagation_stride_1_nsdfg() -> dace.SDFG: def _make_strides_propagation_stride_1_sdfg() -> tuple[dace.SDFG, dace_nodes.NestedSDFG]: - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("strides_propagation_stride_1_sdfg")) + sdfg = dace.SDFG(util.unique_name("strides_propagation_stride_1_sdfg")) state = sdfg.add_state(is_start_block=True) a_stride_sym = dace.symbol("a_stride", dtype=dace.uint32) diff --git a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_vertical_map_split_fusion.py b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_vertical_map_split_fusion.py index 44a0a95f2e..f6e85171d8 100644 --- a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_vertical_map_split_fusion.py +++ b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/test_vertical_map_split_fusion.py @@ -23,9 +23,7 @@ def serial_map_sdfg(N, extra_intermediate_edge=False): sdfg = dace.SDFG( - gtx_transformations.utils.unique_name( - "serial_map" if extra_intermediate_edge else "serial_map_extra_edge" - ) + util.unique_name("serial_map" if extra_intermediate_edge else "serial_map_extra_edge") ) A, _ = sdfg.add_array("A", [N], dtype=dace.float64) B, _ = sdfg.add_array("B", [N], dtype=dace.float64) @@ -152,7 +150,7 @@ def test_vertical_map_fusion_disabled(): @pytest.mark.parametrize("run_map_fusion", [True, False]) def test_vertical_map_fusion_with_neighbor_access(run_map_fusion: bool): N = 80 - sdfg = dace.SDFG(gtx_transformations.utils.unique_name("simple")) + sdfg = dace.SDFG(util.unique_name("simple")) A, _ = sdfg.add_array("A", shape=(N,), dtype=dace.float64, strides=(1,)) B, _ = sdfg.add_array("B", shape=(N,), dtype=dace.float64, strides=(1,)) C, _ = sdfg.add_array("C", shape=(N,), dtype=dace.float64, strides=(1,)) diff --git a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/util.py b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/util.py index 614b937cae..2e957eb406 100644 --- a/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/util.py +++ b/tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/transformation_tests/util.py @@ -11,11 +11,24 @@ import numpy as np import dace import copy +import uuid from dace import data as dace_data, symbolic as dace_sym from dace.sdfg import nodes as dace_nodes -from gt4py.next.program_processors.runners.dace.transformations import ( - utils as gtx_transformations_utils, -) + + +def unique_name(name: str) -> str: + """Adds a unique string to `name`. + + Note: + The names generates by this function are rather unstable and it should + not be used if a particular order should be enforced. This function is + marked for deprecation. + """ + maximal_length = 200 + unique_sufix = str(uuid.uuid1()).replace("-", "_") + if len(name) > (maximal_length - len(unique_sufix)): + name = name[: (maximal_length - len(unique_sufix) - 1)] + return f"{name}_{unique_sufix}" @overload @@ -75,7 +88,7 @@ def compile_and_run_sdfg( with dace.config.set_temporary("compiler.use_cache", value=False): sdfg_clone = copy.deepcopy(sdfg) - sdfg_clone.name = gtx_transformations_utils.unique_name(sdfg_clone.name) + sdfg_clone.name = unique_name(sdfg_clone.name) sdfg_clone._recompile = True sdfg_clone._regenerate_code = True # TODO(phimuell): Find out if it has an effect. csdfg = sdfg_clone.compile() diff --git a/uv.lock b/uv.lock index d172aaa68b..f853aee738 100644 --- a/uv.lock +++ b/uv.lock @@ -1206,7 +1206,7 @@ wheels = [ [[package]] name = "dace" -version = "2.0.0a3" +version = "2.0.0a4" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "astunparse" }, @@ -1223,7 +1223,7 @@ dependencies = [ { name = "sympy" }, { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/c3/f8/2401889078017475ce1293af212b76cfdb8a5771ece179851d441ef363f3/dace-2.0.0a3.tar.gz", hash = "sha256:94cbaac4b1f4ef312d24f4151b0905a0e6292a9cfdf9c8b643dabdb2e95b02fa", size = 6005767, upload-time = "2026-05-11T14:49:16.021Z" } +sdist = { url = "https://files.pythonhosted.org/packages/3a/07/a0410822c1aaef052c0015e7a8399a7d7da76a11e0a97939027c15d125ee/dace-2.0.0a4.tar.gz", hash = "sha256:f45f84b59a34846e0049347559416c1fac39c739aa6cbc791e27e1973d58b1ad", size = 6026693, upload-time = "2026-06-25T14:09:32.009Z" } [[package]] name = "debugpy" @@ -1663,6 +1663,7 @@ dependencies = [ { name = "ninja" }, { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-gt4py-cuda12' and extra == 'extra-5-gt4py-jax-cuda13') or (extra == 'extra-5-gt4py-cuda12' and extra == 'extra-5-gt4py-rocm6') or (extra == 'extra-5-gt4py-cuda12' and extra == 'extra-5-gt4py-rocm7') or (extra == 'extra-5-gt4py-jax-cuda13' and extra == 'extra-5-gt4py-rocm6') or (extra == 'extra-5-gt4py-jax-cuda13' and extra == 'extra-5-gt4py-rocm7') or (extra == 'extra-5-gt4py-rocm6' and extra == 'extra-5-gt4py-rocm7')" }, { name = "numpy", version = "2.4.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-5-gt4py-cuda12' and extra == 'extra-5-gt4py-jax-cuda13') or (extra == 'extra-5-gt4py-cuda12' and extra == 'extra-5-gt4py-rocm6') or (extra == 'extra-5-gt4py-cuda12' and extra == 'extra-5-gt4py-rocm7') or (extra == 'extra-5-gt4py-jax-cuda13' and extra == 'extra-5-gt4py-rocm6') or (extra == 'extra-5-gt4py-jax-cuda13' and extra == 'extra-5-gt4py-rocm7') or (extra == 'extra-5-gt4py-rocm6' and extra == 'extra-5-gt4py-rocm7')" }, + { name = "ordered-set" }, { name = "packaging" }, { name = "pybind11" }, { name = "setuptools" }, @@ -1858,7 +1859,7 @@ requires-dist = [ { name = "cupy-cuda13x", marker = "extra == 'cuda13'", specifier = ">=14.0" }, { name = "cupy-rocm-7-0", marker = "extra == 'rocm7'", specifier = ">=14.0" }, { name = "cytoolz", specifier = ">=1.0.1" }, - { name = "dace", specifier = ">=2.0.0a3" }, + { name = "dace", specifier = ">=2.0.0a4" }, { name = "deepdiff", specifier = ">=8.1.0" }, { name = "devtools", specifier = ">=0.6" }, { name = "factory-boy", specifier = ">=3.3.3" }, @@ -1881,6 +1882,7 @@ requires-dist = [ { name = "ninja", specifier = ">=1.11" }, { name = "numpy", marker = "python_full_version < '3.14'", specifier = ">=2.0.0" }, { name = "numpy", marker = "python_full_version >= '3.14'", specifier = ">=2.3.2" }, + { name = "ordered-set", specifier = ">=4.1.0" }, { name = "packaging", specifier = ">=20.0" }, { name = "pybind11", specifier = ">=3.0.3" }, { name = "pytest", marker = "extra == 'testing'", specifier = ">=7.0" }, @@ -3655,6 +3657,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/23/cd/066e86230ae37ed0be70aae89aabf03ca8d9f39c8aea0dec8029455b5540/opt_einsum-3.4.0-py3-none-any.whl", hash = "sha256:69bb92469f86a1565195ece4ac0323943e83477171b91d24c35afe028a90d7cd", size = 71932, upload-time = "2024-09-26T14:33:23.039Z" }, ] +[[package]] +name = "ordered-set" +version = "4.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4c/ca/bfac8bc689799bcca4157e0e0ced07e70ce125193fc2e166d2e685b7e2fe/ordered-set-4.1.0.tar.gz", hash = "sha256:694a8e44c87657c59292ede72891eb91d34131f6531463aab3009191c77364a8", size = 12826, upload-time = "2022-01-26T14:38:56.6Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/33/55/af02708f230eb77084a299d7b08175cff006dea4f2721074b92cdb0296c0/ordered_set-4.1.0-py3-none-any.whl", hash = "sha256:046e1132c71fcf3330438a539928932caf51ddbc582496833e23de611de14562", size = 7634, upload-time = "2022-01-26T14:38:48.677Z" }, +] + [[package]] name = "orderly-set" version = "5.5.0"