Warn on potential data races

dace/config_schema.yml

@@ -904,6 +904,12 @@ required:
             be called before every compiled SDFG's generated code is invoked. Used
             for functionality such as low-level profiling.
 
+    check_race_conditions:
+        type: bool
+        default: false
+        title: Check race conditions
+        description: Check for probable race conditions during the program's execution.
+
     #############################################
     # Experimental features
 

dace/sdfg/validation.py

@@ -7,6 +7,7 @@
 import warnings
 from dace import dtypes, subsets
 from dace import symbolic
+from dace.sdfg.nodes import AccessNode
 
 if TYPE_CHECKING:
     import dace
@@ -790,6 +791,13 @@ def validate_state(state: 'dace.sdfg.SDFGState',
                     continue
                 raise error
 
+        if Config.get_bool("check_race_conditions"):
+            for node in state.nodes():
+                if isinstance(node, AccessNode):
+                    in_memlet_ranges = [e.data.dst_subset for e in state.in_edges(node)]
+                    if subsets.Range.are_intersecting(in_memlet_ranges):
+                        warnings.warn(f'Memlet range overlap while writing to "{node}" in state "{state.label}"')
+
     ########################################
 
 

dace/subsets.py

@@ -813,6 +813,17 @@ def intersects(self, other: 'Range'):
 
         return True
 
+    @staticmethod
+    def are_intersecting(ranges: List['Range']) -> bool:
+        """ Check if any of the given ranges are intersecting
+            :param ranges: the ranges to be checked.
+        """
+        for i in range(len(ranges)):
+            for j in range(i+1, len(ranges)):
+                if ranges[i].intersects(ranges[j]):
+                    return True
+        return False
+
 
 @dace.serialize.serializable
 class Indices(Subset):

tests/warn_on_potential_data_race_test.py

@@ -0,0 +1,86 @@
+# Copyright 2019-2024 ETH Zurich and the DaCe authors. All rights reserved.
+
+import warnings
+import dace
+import numpy as np
+import pytest
+
+
+def test_memlet_range_not_overlap_ranges():
+    sdfg = dace.SDFG('memlet_range_not_overlap_ranges')
+    state = sdfg.add_state()
+    N = dace.symbol("N", dtype=dace.int32)
+    sdfg.add_array("A", (N//2,), dace.int32)
+    A = state.add_access("A")
+    sdfg.add_array("B", (N,), dace.int32)
+    B = state.add_access("B")
+    state.add_mapped_tasklet(
+        name="first_tasklet",
+        code="b = a + 10",
+        inputs={"a": dace.Memlet(data="A", subset="k")},
+        outputs={"b": dace.Memlet(data="B", subset="k")},
+        map_ranges={"k": "0:N//2"},
+        external_edges=True,
+        input_nodes={"A": A},
+        output_nodes={"B": B}
+    )
+    state.add_mapped_tasklet(
+        name="second_tasklet",
+        code="b = a - 20",
+        inputs={"a": dace.Memlet(data="A", subset="k")},
+        outputs={"b": dace.Memlet(data="B", subset="k+N//2")},
+        map_ranges={"k": "0:N//2"},
+        external_edges=True,
+        input_nodes={"A": A},
+        output_nodes={"B": B}
+    )
+
+    N = 6
+    A = np.arange(N//2, dtype=np.int32)
+    B = np.zeros((N,), dtype=np.int32)
+    with warnings.catch_warnings():
+        warnings.simplefilter("error", UserWarning)
+        with dace.config.set_temporary("check_race_conditions", value=True):
+            sdfg(N=N, A=A, B=B)
+
+
+def test_memlet_range_overlap_ranges():
+    sdfg = dace.SDFG('memlet_range_overlap_ranges')
+    state = sdfg.add_state()
+    N = dace.symbol("N", dtype=dace.int32)
+    sdfg.add_array("A", (N,), dace.int32)
+    A = state.add_access("A")
+    sdfg.add_array("B", (N,), dace.int32)
+    B = state.add_access("B")
+    state.add_mapped_tasklet(
+        name="first_tasklet",
+        code="b = a + 10",
+        inputs={"a": dace.Memlet(data="A", subset="k")},
+        outputs={"b": dace.Memlet(data="B", subset="k")},
+        map_ranges={"k": "0:N"},
+        external_edges=True,
+        input_nodes={"A": A},
+        output_nodes={"B": B}
+    )
+    state.add_mapped_tasklet(
+        name="second_tasklet",
+        code="b = a - 20",
+        inputs={"a": dace.Memlet(data="A", subset="k")},
+        outputs={"b": dace.Memlet(data="B", subset="k")},
+        map_ranges={"k": "0:N"},
+        external_edges=True,
+        input_nodes={"A": A},
+        output_nodes={"B": B}
+    )
+
+    N = 6
+    A = np.arange(N, dtype=np.int32)
+    B = np.zeros((N,), dtype=np.int32)
+    with pytest.warns(UserWarning):
+        with dace.config.set_temporary("check_race_conditions", value=True):
+            sdfg(N=N, A=A, B=B)
+
+
+if __name__ == '__main__':
+    test_memlet_range_not_overlap_ranges()
+    test_memlet_range_overlap_ranges()