WIP: IR

Author: Max Strange

acc/api.py

@@ -65,9 +65,9 @@ def wrapper(*args, **kwargs):
             meta_data = MetaVars(src=source, stackframe=stackframe, signature=signature, funcs_name=funcname, funcs_module=module)
 
             intermediate_rep = IntermediateRepresentation(meta_data)
-            for pragma in frontend.parse_pragmas(intermediate_rep.src, *args, **kwargs):
+            for pragma, linenumber in frontend.parse_pragmas(intermediate_rep.src, *args, **kwargs):
                 # Side-effect-y: this function modifies intermediate_rep each time
-                frontend.accumulate_pragma(intermediate_rep, pragma, *args, **kwargs)
+                frontend.accumulate_pragma(intermediate_rep, pragma, linenumber, *args, **kwargs)
 
             # Pass the intermediate representation into the backend to get the new source code
             new_source = back.compile(intermediate_rep)

acc/backend/backend.py

@@ -48,8 +48,7 @@ def for_loop(code_object, meta_data):
     new_region_src = " " * 4 + "return x * x" + os.linesep
     execute_signature = "ls"
     execute_src = " " * 4 + "p = Pool(5)" + os.linesep
-    execute_src += " " * 4 + "return p.map(task, " + execute_signature + ")" +\
-            os.linesep
+    execute_src += " " * 4 + "return p.map(task, " + execute_signature + ")" + os.linesep
     #-------------------------------------------------------------------
 
     new_src = "from multiprocessing import Pool" + os.linesep

acc/frontend/frontend.py

@@ -14,21 +14,21 @@ def parse_pragmas(src, *args, **kwargs):
     given in `src`.
     """
     regexp = re.compile(r"^((\s)*#(\s)*(pragma)(\s)*(acc))")
-    for line in src.splitlines():
+    for lineno, line in enumerate(src.splitlines()):
         if regexp.match(line):
-            yield line
+            yield line, lineno
 
-def accumulate_pragma(intermediate_rep, pragma, *args, **kwargs):
+def accumulate_pragma(intermediate_rep, pragma, lineno, *args, **kwargs):
     """
     Modifies `intermediate_rep` according to `pragma`.
     """
     directive_and_clauses = pragma.partition("acc")[-1].split(' ')
     directive_and_clauses = [word for word in directive_and_clauses if word != '']
     directive = directive_and_clauses[0]
     clause_list = directive_and_clauses[1:]
-    _accumulate_pragma_helper(directive, clause_list, intermediate_rep, *args, **kwargs)
+    _accumulate_pragma_helper(directive, clause_list, intermediate_rep, lineno, *args, **kwargs)
 
-def _accumulate_pragma_helper(directive, clause_list, intermediate_rep, *args, **kwargs):
+def _accumulate_pragma_helper(directive, clause_list, intermediate_rep, lineno, *args, **kwargs):
     """
     Applies the given directive and its associated clause list
     to the given intermediate_rep.
@@ -44,7 +44,7 @@ def _accumulate_pragma_helper(directive, clause_list, intermediate_rep, *args, *
     elif directive == "host_data":
         pass
     elif directive == "loop":
-        loop(clause_list, intermediate_rep, *args, **kwargs)
+        loop(clause_list, intermediate_rep, lineno, *args, **kwargs)
     elif directive == "atomic":
         pass
     elif directive == "cache":

acc/frontend/loop/loop.py

@@ -14,8 +14,8 @@ class LoopNode(IrNode):
     """
     Node for the IntermediateRepresentation tree that is used for loop constructs.
     """
-    def __init__(self):
-        super().__init__()
+    def __init__(self, lineno: int):
+        super().__init__(lineno)
         self.collapse = None
         self.gang = None
         self.worker = None
@@ -28,7 +28,7 @@ def __init__(self):
         self.private = None
         self.reduction = None
 
-def loop(clauses, intermediate_rep, *args, **kwargs):
+def loop(clauses, intermediate_rep, lineno, *args, **kwargs):
     """
     From the docs:
     The loop construct can describe what type of parallelism to use to
@@ -65,26 +65,31 @@ def loop(clauses, intermediate_rep, *args, **kwargs):
       clause must be written such that the loop iteration count is
       computable when entering the loop construct.
     """
-    loop_node = LoopNode()
-    intermediate_rep.root.add_child(loop_node)
+    loop_node = LoopNode(lineno)
     index = 0
     while index != -1:
-        index = _apply_clause(index, clauses, intermediate_rep)
+        index = _apply_clause(index, clauses, intermediate_rep, loop_node)
+    intermediate_rep.add_child(loop_node)
 
-def _apply_clause(index, clause_list, intermediate_rep):
+def _apply_clause(index, clause_list, intermediate_rep, loop_node):
     """
     Consumes however much of the clause list as necessary to apply the clause
     found at index in the clause_list.
 
-    @param index:       The index into the clause_list of the clause we are
-                        interested in.
+    @param index:               The index into the clause_list of the clause we are
+                                interested in.
 
-    @param clause_list: The list of the clauses that this clause is indexed in.
+    @param clause_list:         The list of the clauses that this clause is indexed in.
 
-    @return:            The new index. If there are no more
-                        clauses after this one is done, index will be -1.
+    @param intermediate_rep:    The intermediate representation, filled with information
+                                about the source code in general, but not yet this node.
+
+    @param loop_node:           The node who's information we are filling in with the clauses.
+
+    @return:                    The new index. If there are no more
+                                clauses after this one is done, index will be -1.
     """
-    args = (index, clause_list, intermediate_rep)
+    args = (index, clause_list, intermediate_rep, loop_node)
     clause = clause_list[index]
     # TODO: Remove this debug print
     print("clause:", clause)
@@ -111,11 +116,10 @@ def _apply_clause(index, clause_list, intermediate_rep):
     elif clause.startswith("reduction"):
         return _reduction(*args)
     else:
-        raise InvalidClauseError("Clause either not allowed for this " +\
-                "directive, or else it may be spelled " +\
-                "incorrectly. Clause given: " + clause)
+        errmsg = "Clause either not allowed for this directive, or else it may be spelled incorrectly. Clause given: {} at line: {}".format(clause, loop_node.lineno)
+        raise InvalidClauseError(errmsg)
 
-def _collapse(index, clause_list, intermediate_rep):
+def _collapse(index, clause_list, intermediate_rep, loop_node):
     """
     The 'collapse' clause is used to specify how many tightly nested loops
     are associated with the 'loop' construct. The argument to the 'collapse'
@@ -158,7 +162,7 @@ def _collapse(index, clause_list, intermediate_rep):
 
     return -1
 
-def _gang(index, clause_list, intermediate_rep):
+def _gang(index, clause_list, intermediate_rep, loop_node):
     """
     When the parent compute construct is a 'parallel' construct, or on an
     orphaned 'loop' construct, the 'gang' clause specifies that the
@@ -199,7 +203,7 @@ def _gang(index, clause_list, intermediate_rep):
     """
     return -1
 
-def _worker(index, clause_list, intermediate_rep):
+def _worker(index, clause_list, intermediate_rep, loop_node):
     """
     When the parent compute construct is a 'parallel' construct, or on an
     orphaned 'loop' construct, the 'worker' clause specifies that the
@@ -227,7 +231,7 @@ def _worker(index, clause_list, intermediate_rep):
     """
     return -1
 
-def _vector(index, clause_list, intermediate_rep):
+def _vector(index, clause_list, intermediate_rep, loop_node):
     """
     When the parent compute construct is a 'parallel' construct, or on an
     orphaned 'loop' construct, the 'vector' clause specifies that the
@@ -256,15 +260,15 @@ def _vector(index, clause_list, intermediate_rep):
     """
     return -1
 
-def _seq(index, clause_list, intermediate_rep):
+def _seq(index, clause_list, intermediate_rep, loop_node):
     """
     The 'seq' clause specifies that the associated loop or loops are to be
     executed sequentially by the acclerator. This clause will override any
     automatic parallelization or vectorization.
     """
     return -1
 
-def _auto(index, clause_list, intermediate_rep):
+def _auto(index, clause_list, intermediate_rep, loop_node):
     """
     The 'auto' clause specifies that the implementation must analyze the
     loop and determine whether to run the loop sequentially. The
@@ -276,7 +280,7 @@ def _auto(index, clause_list, intermediate_rep):
     """
     return -1
 
-def _tile(index, clause_list, intermediate_rep):
+def _tile(index, clause_list, intermediate_rep, loop_node):
     """
     The 'tile' clause specifies that the implementation should split each
     loop nest into two loops, with an outer set of tile loops and an
@@ -303,14 +307,14 @@ def _tile(index, clause_list, intermediate_rep):
     """
     return -1
 
-def _device_type(index, clause_list, intermediate_rep):
+def _device_type(index, clause_list, intermediate_rep, loop_node):
     """
     The 'device_type' clause is described in Section 2.4 Device-Specific
     Clauses.
     """
     return -1
 
-def _independent(index, clause_list, intermediate_rep):
+def _independent(index, clause_list, intermediate_rep, loop_node):
     """
     The 'independent' clause tells the implementation that the iterations of
     this loop are data-independent with respect to each other. This allows
@@ -327,7 +331,7 @@ def _independent(index, clause_list, intermediate_rep):
     """
     return -1
 
-def _private(index, clause_list, intermediate_rep):
+def _private(index, clause_list, intermediate_rep, loop_node):
     """
     The 'private' clause on a 'loop' construct specifies that a copy of each
     item in var-list will be created. If the body of the loop is executed
@@ -341,7 +345,7 @@ def _private(index, clause_list, intermediate_rep):
     """
     return -1
 
-def _reduction(index, clause_list, intermediate_rep):
+def _reduction(index, clause_list, intermediate_rep, loop_node):
     """
     The 'reduction' clause specifies a reduction operator and one or more
     scalar variables. For each reduction variable, a private copy is created

acc/ir/intrep.py

@@ -6,18 +6,21 @@
 about which particular backend it is using (the backend is passed into the
 frontend as an argument).
 """
+import re
 
 class IrNode:
     """
     IntermediateRepresentation tree node. Base class for all types
     of Nodes.
     """
-    def __init__(self, children=None):
+    def __init__(self, lineno, children=None):
         if children is None:
             self.children = []
         else:
             self.children = children
 
+        self.lineno = lineno
+
     def add_child(self, child):
         """
         Adds `child` to this IrNode's list of children.
@@ -28,8 +31,8 @@ class AccNode(IrNode):
     """
     The root of an IntermediateRepresentation tree.
     """
-    def __init__(self):
-        super().__init__()
+    def __init__(self, lineno):
+        super().__init__(lineno)
 
 class IntermediateRepresentation:
     """
@@ -47,6 +50,62 @@ class IntermediateRepresentation:
     def __init__(self, meta_data):
         """
         """
-        self.meta_data = meta_data
-        self.src = meta_data.src
-        self.root = AccNode()
+        self.meta_data = meta_data      # All the meta data
+        self.src = meta_data.src        # Shortcut to the source code
+        self.root = AccNode(0)          # The root of the tree
+        self._lineno_lookup = {}        # A hash table for line number -> IrNode
+
+    def add_child(self, child):
+        """
+        Adds a child node to the tree. Determines where to add the node
+        by seeing what the node's line number is and then going back
+        up in the source code until it finds either the pragma construct
+        that encompasses this new node or else it reaches the top of the
+        function, in which case this node is added as a child of root.
+        """
+        # Add the child to the hash table. There shouldn't already be a node for this line number.
+        assert child.lineno not in self._lineno_lookup, "Line number {} already in hash. Hash: {}".format(child.lineno, self._lineno_lookup)
+        self._lineno_lookup[child.lineno] = child
+
+        # Get the source code above child and reverse it for easy iteration
+        src_lines_above_child = self.src.splitlines()[0:child.lineno]
+        src_lines_above_child.reverse()
+        line_numbers = [i for i in range(0, child.lineno)]
+        line_numbers.reverse()
+
+        # Walk up from here, looking for pragmas
+        regexp = re.compile(r"^((\s)*#(\s)*(pragma)(\s)*(acc))")
+        for lineno, line in zip(line_numbers, src_lines_above_child):
+            if regexp.match(line):
+                # This line is a '#pragma acc' line. Check if it encompasses me.
+                # If it does, we look it up and add the new child to it.
+                # If it does not, then we keep going.
+                if self._pragma_encompasses_child(child, lineno):
+                    parent = self._get_node_by_lineno(lineno)
+                    assert parent is not None, "Could not find node for pragma {} at line {}".format(line, lineno)
+                    parent.add_child(child)
+                    return
+
+        # If we get here without adding the new child to the tree, it is because
+        # we have scanned the whole function and not found any nodes that
+        # encompass the new child. Add the child to the top-level.
+        self.root.add_child(child)
+
+    def _get_node_by_lineno(self, lineno: int) -> IrNode:
+        """
+        Returns a reference to the node that was created for the pragma at the
+        given lineno. If we can't find the node, we return None.
+        """
+        if lineno in self._lineno_lookup:
+            return self._lineno_lookup[lineno]
+        else:
+            return None
+
+    def _pragma_encompasses_child(self, child: IrNode, lineno: int) -> bool:
+        """
+        Returns True if the given child node should be contained in the pragma
+        found in the source code at lineno. Returns False otherwise.
+        """
+        # TODO: Only certain types of constructs can actually encompass others
+        #       Do this method
+        return False