Abstract interpretation based analysis

src/exo/API.py

@@ -17,7 +17,8 @@
 from .frontend.parse_fragment import parse_fragment
 from .frontend.pattern_match import match_pattern
 from .core.prelude import *
-from .rewrite.new_eff import Check_Aliasing
+from .rewrite.analysis import Check_Aliasing
+from .rewrite.dataflow import dataflow_analysis
 
 # Moved to new file
 from .core.proc_eqv import decl_new_proc, derive_proc, assert_eqv_proc, check_eqv_proc
@@ -368,3 +369,11 @@ def is_eq(self, proc: "Procedure"):
 
     def _root(self):
         return IC.Cursor.create(self._loopir_proc)
+
+    def dataflow(self, s=[]):
+        stmts = [s] if isinstance(s, C.StmtCursor) else s
+        loopir_stmts = []
+        for s in stmts:
+            loopir_stmts.append(s._impl._node)
+
+        return dataflow_analysis(self._loopir_proc, loopir_stmts)

src/exo/backend/parallel_analysis.py

@@ -1,6 +1,6 @@
 from ..core.LoopIR import LoopIR, LoopIR_Rewrite
 
-from ..rewrite.new_eff import Check_ParallelizeLoop
+from ..rewrite.analysis import Check_ParallelizeLoop
 
 
 class ParallelAnalysis(LoopIR_Rewrite):

src/exo/core/LoopIR.py

@@ -988,6 +988,13 @@ def get_reads_of_stmts(stmts):
     return gr.reads
 
 
+def get_readconfigs_expr(exprs):
+    gr = GetReadConfigs()
+    for e in exprs:
+        gr.do_e(e)
+    return gr.readconfigs
+
+
 def get_readconfigs(stmts):
     gr = GetReadConfigs()
     for stmt in stmts:

src/exo/frontend/typecheck.py

@@ -247,10 +247,11 @@ def check_single_stmt(self, stmt):
             # Check that field is in config
             if not stmt.config.has_field(stmt.field):
                 self.err(
-                    stmt.field,
-                    f"expected '{stmt.field}'  to be a field "
+                    stmt,
+                    f"expected '{stmt.field}' to be a field "
                     f"in config '{stmt.config.name()}'",
                 )
+                return []
 
             ftyp = stmt.config.lookup_type(stmt.field)
             rhs = self.check_e(
@@ -593,11 +594,13 @@ def check_e(self, e, is_index=False):
         elif isinstance(e, UAST.ReadConfig):
             if not e.config.has_field(e.field):
                 self.err(
-                    e.field,
+                    e,
                     f"'{e.field}' has to be a field in config '{e.config.name()}'",
                 )
+                ftyp = T.err
+            else:
+                ftyp = e.config.lookup_type(e.field)
 
-            ftyp = e.config.lookup_type(e.field)
             return LoopIR.ReadConfig(e.config, e.field, ftyp, e.srcinfo)
         else:
             assert False, "not a LoopIR in check_e"

src/exo/rewrite/LoopIR_scheduling.py

@@ -16,7 +16,7 @@
     get_writes_of_stmts,
     is_const_zero,
 )
-from .new_eff import (
+from .analysis import (
     SchedulingError,
     Check_ReorderStmts,
     Check_ReorderLoops,
@@ -1042,12 +1042,16 @@ def DoCallSwap(call_cursor, new_subproc):
 
     s_new = call_s.update(f=new_subproc)
     ir = call_cursor.get_root()
-    mod_cfg = Check_ExtendEqv(ir, [call_s], [s_new], configkeys)
-    ir, fwd = call_cursor._child_node("f")._replace(new_subproc)
+    new_ir, fwd = call_cursor._child_node("f")._replace(new_subproc)
 
-    Check_Aliasing(ir)
+    if len(configkeys) != 0:
+        configkeys = Check_ExtendEqv(
+            ir, new_ir, [call_cursor._node], [fwd(call_cursor)._node], configkeys
+        )
 
-    return ir, fwd, mod_cfg
+    Check_Aliasing(new_ir)
+
+    return new_ir, fwd, configkeys
 
 
 def DoInlineWindow(window_cursor):
@@ -1236,6 +1240,13 @@ def match_parent(c1, c2):
 
 def DoRewriteExpr(expr_cursor, new_expr):
     proc = expr_cursor.get_root()
+
+    if (
+        not expr_cursor._node.type.is_indexable()
+        and not expr_cursor._node.type.is_bool()
+    ):
+        raise SchedulingError("Cannot rewrite non-index expressions")
+
     s = get_enclosing_stmt_cursor(expr_cursor)._node
     Check_ExprEqvInContext(proc, expr_cursor._node, [s], new_expr, [s])
     return expr_cursor._replace(new_expr)
@@ -2778,10 +2789,20 @@ def err_handler(_, msg):
     return ir, fwd
 
 
+def DoDeleteConfig(proc_cursor, config_cursor):
+    eq_mod_config = Check_DeleteConfigWrite(
+        proc_cursor._node, [config_cursor.prev()._node, config_cursor._node]
+    )
+    p, fwd = config_cursor._delete()
+    return p, fwd, eq_mod_config
+
+
+"""
 def DoDeleteConfig(proc_cursor, config_cursor):
     eq_mod_config = Check_DeleteConfigWrite(proc_cursor._node, [config_cursor._node])
     p, fwd = config_cursor._delete()
     return p, fwd, eq_mod_config
+"""
 
 
 def DoDeletePass(proc):

src/exo/rewrite/LoopIR_unification.py

@@ -18,7 +18,7 @@
 )
 from .LoopIR_scheduling import SchedulingError
 from ..core.prelude import *
-from .new_eff import Check_Aliasing
+from .analysis import Check_Aliasing
 import exo.core.internal_cursors as ic