New and Improved MapFusion

dace/subsets.py

@@ -80,7 +80,7 @@ def covers(self, other):
         # Subsets of different dimensionality can never cover each other.
         if self.dims() != other.dims():
             return ValueError(
-                    f"A subset of dimensionality {self.dim()} cannot test covering a subset of dimensionality {other.dims()}"
+                    f"A subset of dimensionality {self.dims()} cannot test covering a subset of dimensionality {other.dims()}"
             )
 
         if not Config.get('optimizer', 'symbolic_positive'):
@@ -106,7 +106,7 @@ def covers_precise(self, other):
         # Subsets of different dimensionality can never cover each other.
         if self.dims() != other.dims():
             return ValueError(
-                    f"A subset of dimensionality {self.dim()} cannot test covering a subset of dimensionality {other.dims()}"
+                    f"A subset of dimensionality {self.dims()} cannot test covering a subset of dimensionality {other.dims()}"
             )
 
         # If self does not cover other with a bounding box union, return false.

dace/transformation/auto/auto_optimize.py

@@ -58,7 +58,10 @@ def greedy_fuse(graph_or_subgraph: GraphViewType,
             # If we have an SDFG, recurse into graphs
             graph_or_subgraph.simplify(validate_all=validate_all)
             # MapFusion for trivial cases
-            graph_or_subgraph.apply_transformations_repeated(MapFusion, validate_all=validate_all)
+            graph_or_subgraph.apply_transformations_repeated(
+                    MapFusion(strict_dataflow=True),
+                    validate_all=validate_all,
+            )
 
         # recurse into graphs
         for graph in graph_or_subgraph.nodes():
@@ -76,7 +79,10 @@ def greedy_fuse(graph_or_subgraph: GraphViewType,
         sdfg, graph, subgraph = None, None, None
         if isinstance(graph_or_subgraph, SDFGState):
             sdfg = graph_or_subgraph.parent
-            sdfg.apply_transformations_repeated(MapFusion, validate_all=validate_all)
+            sdfg.apply_transformations_repeated(
+                    MapFusion(strict_dataflow=True),
+                    validate_all=validate_all,
+            )
             graph = graph_or_subgraph
             subgraph = SubgraphView(graph, graph.nodes())
         else:

dace/transformation/dataflow/buffer_tiling.py

@@ -98,7 +98,13 @@ def apply(self, graph, sdfg):
 
         # Fuse maps
         some_buffer = next(iter(buffers))  # some dummy to pass to MapFusion.apply_to()
-        MapFusion.apply_to(sdfg, first_map_exit=tile_map1_exit, array=some_buffer, second_map_entry=tile_map2_entry)
+        MapFusion.apply_to(
+                sdfg,
+                first_map_exit=tile_map1_exit,
+                array=some_buffer,
+                second_map_entry=tile_map2_entry,
+                verify=True,
+        )
 
         # Optimize the simple cases
         map1_entry.range.ranges = [

tests/buffer_tiling_test.py

@@ -78,6 +78,7 @@ def _semantic_eq(tile_sizes, program):
 
     count = sdfg.apply_transformations(BufferTiling, options={'tile_sizes': tile_sizes})
     assert count > 0
+    sdfg.validate()
     sdfg(w3=w3, w5=w5, A=A, B=B2, I=A.shape[0], J=A.shape[1])
 
     assert np.allclose(B1, B2)

tests/npbench/polybench/correlation_test.py

@@ -83,7 +83,8 @@ def run_correlation(device_type: dace.dtypes.DeviceType):
     # Compute ground truth and validate result
 
     corr_ref = ground_truth(M, float_n_ref, data_ref)
-    assert np.allclose(corr, corr_ref)
+    diff = corr_ref - corr
+    assert np.abs(diff).max() <= 10e-10
     return sdfg
 
 

tests/npbench/polybench/heat_3d_test.py

@@ -64,10 +64,22 @@ def run_heat_3d(device_type: dace.dtypes.DeviceType):
     A_ref = np.copy(A)
     B_ref = np.copy(B)
 
+    def count_maps(sdfg: dc.SDFG) -> int:
+        nb_maps = 0
+        for _, state in sdfg.all_nodes_recursive():
+            node: dc.SDFGState
+            for node in state.nodes():
+                if isinstance(node, dc.sdfg.nodes.MapEntry):
+                    nb_maps += 1
+        return nb_maps
+
     if device_type in {dace.dtypes.DeviceType.CPU, dace.dtypes.DeviceType.GPU}:
         # Parse the SDFG and apply auto-opt
         sdfg = heat_3d_kernel.to_sdfg()
+        initial_maps = count_maps(sdfg)
         sdfg = auto_optimize(sdfg, device_type)
+        after_maps = count_maps(sdfg)
+        assert after_maps < initial_maps, f"Expected less maps, initially {initial_maps} many maps, but after optimization {after_maps}"
         sdfg(TSTEPS, A, B, N=N)
     elif device_type == dace.dtypes.DeviceType.FPGA:
         # Parse SDFG and apply FPGA friendly optimization

tests/npbench/polybench/jacobi_2d_test.py

@@ -47,6 +47,7 @@ def run_jacobi_2d(device_type: dace.dtypes.DeviceType):
         # Parse the SDFG and apply autopot
         sdfg = kernel.to_sdfg()
         sdfg = auto_optimize(sdfg, device_type)
+
         sdfg(A=A, B=B, TSTEPS=TSTEPS, N=N)
 
     elif device_type == dace.dtypes.DeviceType.FPGA:

tests/python_frontend/fields_and_global_arrays_test.py

@@ -585,7 +585,7 @@ def caller():
 
     # Ensure only three globals are created
     sdfg = caller.to_sdfg()
-    assert len([k for k in sdfg.arrays if '__g' in k]) == 3
+    assert len([k for k in sdfg.arrays if k.startswith('__g')]) == 3
 
 
 def test_two_inner_methods():

tests/transformations/apply_to_test.py

@@ -15,6 +15,7 @@ def dbladd(A: dace.float64[100, 100], B: dace.float64[100, 100]):
     dbl = B
     return A + dbl * B
 
+
 @dace.program
 def unfusable(A: dace.float64[100], B: dace.float64[100, 100]):
     """Test function of two maps that can not be fused."""
@@ -57,8 +58,12 @@ def test_applyto_pattern():
     transient = next(aname for aname, desc in sdfg.arrays.items() if desc.transient)
     access_node = next(n for n in state.nodes() if isinstance(n, dace.nodes.AccessNode) and n.data == transient)
 
-    assert MapFusion.can_be_applied_to(sdfg, first_map_exit=mult_exit, array=access_node, second_map_entry=add_entry)
-
+    assert MapFusion.can_be_applied_to(
+            sdfg,
+            first_map_exit=mult_exit,
+            array=access_node,
+            second_map_entry=add_entry
+    )
     MapFusion.apply_to(sdfg, first_map_exit=mult_exit, array=access_node, second_map_entry=add_entry)
 
     assert len([node for node in state.nodes() if isinstance(node, dace.nodes.MapEntry)]) == 1

tests/transformations/mapfusion_data_races_test.py

@@ -41,6 +41,13 @@ def rw_data_race_3(A: dace.float64[20], B: dace.float64[20]):
     A[:10] += 3.0 * offset(A[:11])
 
 
+@dace.program
+def rw_data_race_4(A: dace.float64[20], B: dace.float64[20]):
+    # This is potentially fusable
+    A += B
+    A *= 2.0
+
+
 def test_rw_data_race():
     sdfg = rw_data_race.to_sdfg(simplify=True)
     sdfg.apply_transformations_repeated(MapFusion)
@@ -50,8 +57,9 @@ def test_rw_data_race():
 
 def test_rw_data_race_2_mf():
     sdfg = rw_data_race_2.to_sdfg(simplify=True)
-    sdfg.apply_transformations_repeated(MapFusion)
+    nb_applied = sdfg.apply_transformations_repeated(MapFusion)
     map_entry_nodes = [n for n, _ in sdfg.all_nodes_recursive() if isinstance(n, nodes.MapEntry)]
+    assert nb_applied > 0
     assert (len(map_entry_nodes) > 1)
 
 
@@ -69,8 +77,27 @@ def test_rw_data_race_3_sgf():
     assert (len(map_entry_nodes) > 1)
 
 
+def test_rw_data_race_3_mf():
+    sdfg = rw_data_race_3.to_sdfg(simplify=True)
+    nb_applied = sdfg.apply_transformations_repeated(MapFusion)
+    map_entry_nodes = [n for n, _ in sdfg.all_nodes_recursive() if isinstance(n, nodes.MapEntry)]
+    assert (len(map_entry_nodes) > 1)
+    assert nb_applied > 0
+
+
+def test_rw_data_race_4_mf():
+    # It is technically possible to fuse it, because there is only a point wise dependency.
+    #  However, it is very hard to detect and handle correct.
+    sdfg = rw_data_race_4.to_sdfg(simplify=True)
+    sdfg.apply_transformations_repeated(MapFusion)
+    map_entry_nodes = [n for n, _ in sdfg.all_nodes_recursive() if isinstance(n, nodes.MapEntry)]
+    assert (len(map_entry_nodes) >= 1)
+
+
 if __name__ == "__main__":
     test_rw_data_race()
-    test_rw_data_race_2_mf()
     test_rw_data_race_2_sgf()
+    test_rw_data_race_2_mf()
     test_rw_data_race_3_sgf()
+    test_rw_data_race_3_mf()
+    test_rw_data_race_4_mf()