New dependency finding

loopy/kernel/__init__.py

@@ -80,6 +80,20 @@ class _BoundsRecord:
     upper_bound_pw_aff: isl.PwAff
     size: isl.PwAff
 
+@dataclass(frozen=True)
+class RelationInfo:
+    insn_id: str
+    var_name: str
+    relation: isl.Map
+
+@dataclass(frozen=True)
+class AccessRelation(RelationInfo):
+    access_type: str
+
+@dataclass(frozen=True)
+class DependencyRelation(RelationInfo):
+    dependent_id: str
+    dependency_type: str
 
 PreambleGenerator = Callable[["PreambleInfo"], Iterator[Tuple[int, str]]]
 
@@ -640,6 +654,81 @@ def _remove_inames_for_shared_hw_axes(self, cond_inames):
 
     # {{{ dependency wrangling
 
+    def generate_access_relations(self):
+        from loopy.symbolic import BatchedAccessMapMapper
+        bmap = BatchedAccessMapMapper(self, self.all_variable_names())
+        for insn in self.instructions:
+            bmap(insn.assignee, insn.within_inames)
+            bmap(insn.expression, insn.within_inames)
+
+        def get_map(var, insn):
+            return bmap.access_maps[var][insn.within_inames]
+
+        def read_var_list(insn):
+            return insn.read_dependency_names() - insn.within_inames
+
+        def write_var_list(insn):
+            return insn.write_dependency_names() - insn.within_inames
+
+        read_maps = [AccessRelation(insn.id, var, get_map(var, insn), "read")
+                     for insn in self.instructions
+                     for var in read_var_list(insn)]
+        write_maps = [AccessRelation(insn.id, var, get_map(var, insn), "write")
+                      for insn in self.instructions
+                      for var in write_var_list(insn)]
+
+        return read_maps, write_maps
+
+    def generate_dependency_relations(self, read_maps, write_maps):
+
+        def get_dependency_relation(x, y):
+
+            # TODO deal with self dependencies
+            #self_dependency = x.relation.apply_range(x.relation.reverse())
+
+            dependency_relation = x.relation.apply_range(y.relation.reverse())
+            #dependency_relation -= self_dependency
+
+            return dependency_relation 
+
+        write_read = [DependencyRelation(write.insn_id, write.var_name,
+                                         get_dependency_relation(write, read),
+                                         read.insn_id, "write-read")
+                      for write in write_maps
+                      for read in read_maps
+                      if write.var_name == read.var_name]
+
+        read_write = [DependencyRelation(read.insn_id, read.var_name,
+                                         get_dependency_relation(read, write),
+                                         write.insn_id, "read-write")
+                      for read in read_maps
+                      for write in write_maps
+                      if read.var_name == write.var_name]
+
+        write_write = [DependencyRelation(write1.insn_id, write1.var_name,
+                                          get_dependency_relation(write1, write2),
+                                          write2.insn_id, "write-write")
+                       for write1 in write_maps
+                       for write2 in write_maps
+                       if write1.var_name == write2.var_name]
+
+        # update depends_on for each instruction
+        for insn in self.instructions:
+            for relation in write_read:
+                if relation.dependent_id == insn.id:
+                    insn.update_depends_on(relation.insn_id)
+            for relation in read_write:
+                if relation.dependent_id == insn.id:
+                    insn.update_depends_on(relation.insn_id)
+            for relation in write_write:
+                if relation.dependent_id == insn.id:
+                    insn.update_depends_on(relation.insn_id)
+
+        return write_read, read_write, write_write
+
+    def dep_finder(self):
+        pass
+
     @memoize_method
     def recursive_insn_dep_map(self):
         """Returns a :class:`dict` mapping an instruction IDs *a*

loopy/kernel/instruction.py

@@ -315,6 +315,10 @@ def __init__(self, id, depends_on, depends_on_is_final,
 
     # {{{ abstract interface
 
+    def update_depends_on(self, dependee):
+        update = frozenset({dependee})
+        self.depends_on = self.depends_on | update
+
     def read_dependency_names(self):
         from loopy.symbolic import get_dependencies
         result = frozenset()
@@ -471,7 +475,6 @@ def __setstate__(self, val):
 
 # }}}
 
-
 def _get_assignee_var_name(expr):
     from pymbolic.primitives import Variable, Subscript, Lookup
     from loopy.symbolic import LinearSubscript, SubArrayRef