Dependency finding

loopy/kernel/creation.py

@@ -1441,32 +1441,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):
@@ -1920,7 +1894,8 @@ def apply_single_writer_depencency_heuristic(kernel, warn_if_used=True,
                 if error_if_used:
                     raise LoopyError(msg)
 
-                insn = insn.copy(depends_on=new_deps)
+#                insn = insn.copy(depends_on=new_deps)
+                insn = insn.copy(happens_after=new_deps)
                 changed = True
 
         new_insns.append(insn)
@@ -2490,7 +2465,7 @@ def make_function(domains, instructions, kernel_data=None, **kwargs):
     check_for_duplicate_insn_ids(knl)
 
     if seq_dependencies:
-        knl = add_sequential_dependencies(knl)
+        knl = add_lexicographic_happens_after(knl)
 
     assert len(knl.instructions) == len(inames_to_dup)
 

loopy/kernel/dependency.py

@@ -0,0 +1,112 @@
+import pymbolic.primitives as p
+
+from dataclasses import dataclass
+from islpy import Map
+from typing import FrozenSet, Optional, List
+
+from loopy import LoopKernel
+from loopy import InstructionBase
+from loopy.symbolic import WalkMapper
+
+@dataclass(frozen=True)
+class HappensAfter:
+    variable_name: Optional[str]
+    instances_rel: Optional[Map]
+
+class AccessMapMapper(WalkMapper):
+    """
+    TODO Update this documentation so it reflects proper formatting
+
+    Used instead of BatchedAccessMapMapper to get single access maps for each
+    instruction. 
+    """
+
+    def __init__(self, kernel, var_names):
+        self.kernel = kernel
+        self._var_names = var_names
+
+        from collections import defaultdict
+        self.access_maps = defaultdict(lambda:
+                           defaultdict(lambda:
+                           defaultdict(lambda: None)))
+
+        super.__init__()
+
+    def map_subscript(self, expr, inames, insn_id):    
+
+        domain = self.kernel.get_inames_domain(inames)
+
+        # why do we need this?
+        WalkMapper.map_subscript(self, expr, inames)
+
+        assert isinstance(expr.aggregate, p.Variable)
+
+        if expr.aggregate.name not in self._var_names:
+            return
+
+        arg_name = expr.aggregate.name
+        subscript = expr.index_tuple
+
+        descriptor = self.kernel.get_var_descriptor(arg_name)
+
+        from loopy.diagnostic import UnableToDetermineAccessRangeError
+        from loopy.symbolic import get_access_map
+
+        try:
+            access_map = get_access_map(domain, subscript)
+        except UnableToDetermineAccessRangeError:
+            return
+
+        if self.access_maps[insn_id][arg_name][inames] is None:
+            self.access_maps[insn_id][arg_name][inames] = access_map
+
+def compute_happens_after(knl: LoopKernel) -> LoopKernel: 
+    """
+    TODO Update documentation to reflect the proper format.
+
+    Determine dependency relations that exist between instructions. Similar to
+    apply_single_writer_dependency_heuristic. Extremely rough draft.
+    """
+    writer_map = knl.writer_map()
+    variables = knl.all_variable_names - knl.inames.keys()
+
+    amap = AccessMapMapper(knl, variables)
+
+    dep_map = {
+        insn.id: insn.read_dependency_names() - insn.within_inames
+        for insn in knl.instructions
+    }
+
+    new_insns = []
+    for insn in knl.instructions:
+        current_insn = insn.id
+        inames = insn.within_inames
+
+        new_happens_after = []
+        for var in dep_map[insn.id]:
+            for writer in (writer_map.get(var, set()) - { current_insn }):
+
+                # get relation for current instruction and a write instruction
+                cur_relation = amap.access_maps[current_insn][var][inames] 
+                write_relation = amap.access_maps[writer][var][inames]
+
+                # compute the dependency relation
+                dep_relation = cur_relation.apply_range(write_relation.reverse())
+
+                # create the mapping from writer -> (variable, dependency rel'n)
+                happens_after = HappensAfter(var, dep_relation)
+                happens_after_mapping = { writer: happens_after }
+
+                # add to the new list of dependencies
+                new_happens_after |= happens_after_mapping
+
+        # update happens_after of our current instruction with the mapping 
+        insn = insn.copy(happens_after=new_happens_after)
+        new_insns.append(insn)
+
+    # return the kernel with the new instructions
+    return knl.copy(instructions=new_insns)
+
+def add_lexicographic_happens_after(knl: LoopKernel) -> None:
+    pass
+