Dependency finding

.gitignore

@@ -20,6 +20,7 @@ htmlcov
 lextab.py
 yacctab.py
 .pytest_cache/*
+.DS_STORE
 
 loopy/_git_rev.py
 

doc/ref_kernel.rst

@@ -262,6 +262,7 @@ Instructions
 
 .. {{{
 
+.. autoclass:: HappensAfter
 .. autoclass:: InstructionBase
 
 .. _assignments:
@@ -459,6 +460,10 @@ Loopy's expressions are a slight superset of the expressions supported by
 TODO: Functions
 TODO: Reductions
 
+Dependencies
+^^^^^^^^^^^^
+.. automodule:: loopy.kernel.dependency
+
 Function Call Instructions
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 

doc/ref_transform.rst

@@ -13,6 +13,10 @@ Wrangling inames
 
 .. automodule:: loopy.transform.iname
 
+Precise Dependency Finding
+--------------------------
+.. automodule:: loopy.transform.dependency
+
 Dealing with Substitution Rules
 -------------------------------
 

loopy/__init__.py

@@ -29,6 +29,7 @@
 # {{{ imported user interface
 
 from loopy.kernel.instruction import (
+        HappensAfter,
         LegacyStringInstructionTag, UseStreamingStoreTag,
         MemoryOrdering,
         MemoryScope,
@@ -175,6 +176,7 @@
         "LoopKernel",
         "KernelState",
 
+        "HappensAfter",
         "LegacyStringInstructionTag", "UseStreamingStoreTag",
         "MemoryOrdering",
         "MemoryScope",

loopy/check.py

@@ -1058,7 +1058,6 @@ def _check_variable_access_ordered_inner(kernel):
     depends_on = {insn.id: set() for insn in kernel.instructions}
     # rev_depends: mapping from insn_ids to their reverse deps.
     rev_depends = {insn.id: set() for insn in kernel.instructions}
-
     for insn in kernel.instructions:
         depends_on[insn.id].update(insn.depends_on)
         for dep in insn.depends_on:

loopy/kernel/creation.py

@@ -193,7 +193,7 @@ def subst_func(var):
 
 def get_default_insn_options_dict():
     return {
-        "depends_on": frozenset(),
+        "happens_after": frozenset(),
         "depends_on_is_final": False,
         "no_sync_with": frozenset(),
         "groups": frozenset(),
@@ -289,14 +289,15 @@ def parse_nosync_option(opt_value):
                 result["depends_on_is_final"] = True
                 opt_value = (opt_value[1:]).strip()
 
-            result["depends_on"] = result["depends_on"].union(frozenset(
+            result["happens_after"] = result["happens_after"].union(frozenset(
                     intern(dep.strip()) for dep in opt_value.split(":")
                     if dep.strip()))
 
         elif opt_key == "dep_query" and opt_value is not None:
             from loopy.match import parse_match
             match = parse_match(opt_value)
-            result["depends_on"] = result["depends_on"].union(frozenset([match]))
+            result["happens_after"] = result["happens_after"].union(
+                                                            frozenset([match]))
 
         elif opt_key == "nosync" and opt_value is not None:
             if is_with_block:
@@ -684,6 +685,7 @@ def _count_open_paren_symbols(s):
 
 
 def parse_instructions(instructions, defines):
+
     if isinstance(instructions, str):
         instructions = [instructions]
 
@@ -716,8 +718,8 @@ def intern_if_str(s):
 
             copy_args = {
                 "id": intern_if_str(insn.id),
-                "depends_on": frozenset(intern_if_str(dep)
-                    for dep in insn.depends_on),
+                "happens_after": frozenset(intern_if_str(dep)
+                    for dep in insn.happens_after),
                 "groups": frozenset(checked_intern(grp) for grp in insn.groups),
                 "conflicts_with_groups": frozenset(
                     checked_intern(grp) for grp in insn.conflicts_with_groups),
@@ -834,11 +836,11 @@ def intern_if_str(s):
                             # If it's inside a for/with block, then it's
                             # final now.
                             bool(local_w_inames)),
-                        depends_on=(
+                        happens_after=(
                             (insn.depends_on
-                                | insn_options_stack[-1]["depends_on"])
-                            if insn_options_stack[-1]["depends_on"] is not None
-                            else insn.depends_on),
+                                | insn_options_stack[-1]["happens_after"])
+                            if insn_options_stack[-1]["happens_after"] is not None
+                            else insn.happens_after),
                         tags=(
                             insn.tags
                             | insn_options_stack[-1]["tags"]),
@@ -1441,32 +1443,6 @@ def add_assignment(base_name, expr, dtype, additional_inames):
 # }}}
 
 
-# {{{ add_sequential_dependencies
-
-def add_sequential_dependencies(knl):
-    new_insns = []
-    prev_insn = None
-    for insn in knl.instructions:
-        depon = insn.depends_on
-        if depon is None:
-            depon = frozenset()
-
-        if prev_insn is not None:
-            depon = depon | frozenset((prev_insn.id,))
-
-        insn = insn.copy(
-                depends_on=depon,
-                depends_on_is_final=True)
-
-        new_insns.append(insn)
-
-        prev_insn = insn
-
-    return knl.copy(instructions=new_insns)
-
-# }}}
-
-
 # {{{ temporary variable creation
 
 def create_temporaries(knl, default_order):
@@ -1816,18 +1792,20 @@ def resolve_dependencies(knl):
     new_insns = []
 
     for insn in knl.instructions:
-        depends_on = _resolve_dependencies(
-                "a dependency", knl, insn, insn.depends_on)
+        happens_after = _resolve_dependencies(
+                "a dependency", knl, insn, insn.happens_after)
         no_sync_with = frozenset(
                 (resolved_insn_id, nosync_scope)
                 for nosync_dep, nosync_scope in insn.no_sync_with
                 for resolved_insn_id in
                 _resolve_dependencies("nosync", knl, insn, (nosync_dep,)))
 
-        if depends_on == insn.depends_on and no_sync_with == insn.no_sync_with:
+        if happens_after == insn.happens_after and \
+                no_sync_with == insn.no_sync_with:
             new_insn = insn
         else:
-            new_insn = insn.copy(depends_on=depends_on, no_sync_with=no_sync_with)
+            new_insn = insn.copy(happens_after=happens_after,
+                                 no_sync_with=no_sync_with)
         new_insns.append(new_insn)
 
     return knl.copy(instructions=new_insns)
@@ -1921,13 +1899,17 @@ def apply_single_writer_depencency_heuristic(kernel, warn_if_used=True,
 
             # }}}
 
-            depends_on = insn.depends_on
-            if depends_on is None:
-                depends_on = frozenset()
+            happens_after = insn.happens_after
+
+            if not isinstance(happens_after, frozenset):
+                happens_after = frozenset(happens_after)
 
-            new_deps = frozenset(auto_deps) | depends_on
+            if happens_after is None:
+                happens_after = frozenset()
 
-            if new_deps != depends_on:
+            new_deps = frozenset(auto_deps) | frozenset(happens_after)
+
+            if new_deps != happens_after:
                 msg = (
                     "The single-writer dependency heuristic added dependencies "
                     "on instruction ID(s) '%s' to instruction ID '%s' after "
@@ -1936,13 +1918,13 @@ def apply_single_writer_depencency_heuristic(kernel, warn_if_used=True,
                     "To fix this, ensure that instruction dependencies "
                     "are added/resolved as soon as possible, ideally at kernel "
                     "creation time."
-                    % (", ".join(new_deps - depends_on), insn.id))
+                    % (", ".join(new_deps - happens_after), insn.id))
                 if warn_if_used:
                     warn_with_kernel(kernel, "single_writer_after_creation", msg)
                 if error_if_used:
                     raise LoopyError(msg)
 
-                insn = insn.copy(depends_on=new_deps)
+                insn = insn.copy(happens_after=new_deps)
                 changed = True
 
         new_insns.append(insn)
@@ -2523,7 +2505,8 @@ def make_function(domains, instructions, kernel_data=None, **kwargs):
     check_for_duplicate_insn_ids(knl)
 
     if seq_dependencies:
-        knl = add_sequential_dependencies(knl)
+        from loopy.kernel.dependency import add_lexicographic_happens_after
+        knl = add_lexicographic_happens_after(knl)
 
     assert len(knl.instructions) == len(inames_to_dup)
 
@@ -2565,7 +2548,10 @@ def make_function(domains, instructions, kernel_data=None, **kwargs):
     knl = guess_arg_shape_if_requested(knl, default_order)
     knl = apply_default_order_to_args(knl, default_order)
     knl = resolve_dependencies(knl)
-    knl = apply_single_writer_depencency_heuristic(knl, warn_if_used=False)
+
+    # precise dependency semantics should not rely on this
+    if not seq_dependencies:
+        knl = apply_single_writer_depencency_heuristic(knl, warn_if_used=False)
 
     # -------------------------------------------------------------------------
     # Ordering dependency:

loopy/kernel/dependency.py

@@ -0,0 +1,122 @@
+"""
+.. autofunction:: add_lexicographic_happens_after
+"""
+
+__copyright__ = "Copyright (C) 2023 Addison Alvey-Blanco"
+
+__license__ = """
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+"""
+
+import islpy as isl
+from islpy import dim_type
+
+from loopy import LoopKernel
+from loopy.kernel.instruction import HappensAfter
+from loopy.translation_unit import for_each_kernel
+
+
+@for_each_kernel
+def add_lexicographic_happens_after(knl: LoopKernel) -> LoopKernel:
+    """Construct a sequential dependency specification between each instruction
+    and the instruction immediately before it. This dependency information
+    contains a lexicographic map which acts as a description of the precise,
+    statement-instance level dependencies between statements.
+    """
+
+    new_insns = []
+
+    for iafter, insn_after in enumerate(knl.instructions):
+
+        if iafter == 0:
+            new_insns.append(insn_after)
+
+        else:
+
+            insn_before = knl.instructions[iafter - 1]
+            shared_inames = insn_after.within_inames & insn_before.within_inames
+
+            domain_before = knl.get_inames_domain(insn_before.within_inames)
+            domain_after = knl.get_inames_domain(insn_after.within_inames)
+            happens_before = isl.Map.from_domain_and_range(
+                    domain_before, domain_after
+            )
+
+            for idim in range(happens_before.dim(dim_type.out)):
+                happens_before = happens_before.set_dim_name(
+                        dim_type.out, idim,
+                        happens_before.get_dim_name(dim_type.out, idim) + "'"
+                )
+
+            n_inames_before = happens_before.dim(dim_type.in_)
+            happens_before_set = happens_before.move_dims(
+                    dim_type.out, 0,
+                    dim_type.in_, 0,
+                    n_inames_before).range()
+
+            shared_inames_order_before = [
+                    domain_before.get_dim_name(dim_type.out, idim)
+                    for idim in range(domain_before.dim(dim_type.out))
+                    if domain_before.get_dim_name(dim_type.out, idim)
+                    in shared_inames
+            ]
+            shared_inames_order_after = [
+                    domain_after.get_dim_name(dim_type.out, idim)
+                    for idim in range(domain_after.dim(dim_type.out))
+                    if domain_after.get_dim_name(dim_type.out, idim)
+                    in shared_inames
+            ]
+            assert shared_inames_order_after == shared_inames_order_before
+            shared_inames_order = shared_inames_order_after
+
+            affs = isl.affs_from_space(happens_before_set.space)
+
+            lex_set = isl.Set.empty(happens_before_set.space)
+            for iinnermost, innermost_iname in enumerate(shared_inames_order):
+
+                innermost_set = affs[innermost_iname].lt_set(
+                        affs[innermost_iname+"'"]
+                )
+
+                for outer_iname in shared_inames_order[:iinnermost]:
+                    innermost_set = innermost_set & (
+                            affs[outer_iname].eq_set(affs[outer_iname + "'"])
+                    )
+
+                lex_set = lex_set | innermost_set
+
+            lex_map = isl.Map.from_range(lex_set).move_dims(
+                    dim_type.in_, 0,
+                    dim_type.out, 0,
+                    n_inames_before)
+
+            happens_before = happens_before & lex_map
+
+            new_happens_after = {
+                insn_before.id: HappensAfter(None, happens_before)
+            }
+
+            insn_after = insn_after.copy(happens_after=new_happens_after)
+
+            new_insns.append(insn_after)
+
+    return knl.copy(instructions=new_insns)
+
+
+# vim: foldmethod=marker