Dependency finding

.gitignore

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

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):
@@ -1794,18 +1770,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)
@@ -1899,13 +1877,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)
+
+            if happens_after is None:
+                happens_after = frozenset()
 
-            new_deps = frozenset(auto_deps) | depends_on
+            new_deps = frozenset(auto_deps) | frozenset(happens_after)
 
-            if new_deps != depends_on:
+            if new_deps != happens_after:
                 msg = (
                     "The single-writer dependency heuristic added dependencies "
                     "on instruction ID(s) '%s' to instruction ID '%s' after "
@@ -1914,13 +1896,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)
@@ -2497,7 +2479,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)