(Closes #2499) scalarization transformation implementation

.github/workflows/nemo_tests.yml

@@ -96,6 +96,13 @@ jobs:
         module load perl/${PERL_VERSION}
         make -j 4 passthrough
         make -j 4 compile-passthrough
+        make run-passthrough |& tee output.txt
+        # Check the output is as expected for the first 6 digits (if not exit with error message)
+        tail -n 1 output.txt | grep -q " it :      10"  || (echo "Error: 'it :      10' not found!" & false)
+        tail -n 1 output.txt | grep -q "|ssh|_max:  0.259483" || (echo "Error: '|ssh|_max:  0.259483' not found!" & false)
+        tail -n 1 output.txt | grep -q "|U|_max:  0.458515" || (echo "Error: '|U|_max:  0.458515' not found!" & false)
+        tail -n 1 output.txt | grep -q "S_min:  0.482686" || (echo "Error: 'S_min:  0.482686' not found!" & false)
+        tail -n 1 output.txt | grep -q "S_max:  0.407622" || (echo "Error: 'S_max:  0.407622' not found!" & false)
 
     # PSyclone, compile and run MetOffice NEMO with OpenMP for GPUs
     - name: NEMO MetOffice OpenMP for GPU

doc/user_guide/transformations.rst

@@ -569,6 +569,13 @@ can be found in the API-specific sections).
 
 ####
 
+.. autoclass:: psyclone.psyir.transformations.ScalarizationTrans
+      :members: apply
+      :noindex:
+
+####
+
+
 Algorithm-layer
 ---------------
 

examples/nemo/scripts/omp_cpu_trans.py

@@ -44,6 +44,9 @@
     PRIVATISATION_ISSUES)
 from psyclone.psyir.nodes import Routine
 from psyclone.transformations import OMPLoopTrans
+# TODO Remove
+from psyclone.psyir.transformations import ScalarizationTrans
+from psyclone.psyir.nodes import Loop
 
 # Enable the insertion of profiling hooks during the transformation script
 PROFILING_ENABLED = False
@@ -72,6 +75,13 @@ def trans(psyir):
     :type psyir: :py:class:`psyclone.psyir.nodes.FileContainer`
 
     '''
+    # TODO Remove
+    scalartrans = ScalarizationTrans()
+    for subroutine in psyir.walk(Routine):
+        loops = subroutine.walk(Loop)
+        loops.reverse()
+        for loop in loops:
+            scalartrans.apply(loop)
 
     # If the environemnt has ONLY_FILE defined, only process that one file and
     # nothing else. This is useful for file-by-file exhaustive tests.

examples/nemo/scripts/passthrough.py

@@ -41,5 +41,5 @@
 FILES_TO_SKIP = []
 
 
-def trans(_):
+def trans(psyir):
     ''' Don't do any changes. '''

src/psyclone/core/symbolic_maths.py

@@ -269,6 +269,39 @@ def greater_than(exp1, exp2, all_variables_positive=None):
             return SymbolicMaths.Fuzzy.TRUE
         return SymbolicMaths.Fuzzy.FALSE
 
+    @staticmethod
+    def less_than(exp1, exp2, all_variables_positive=None):
+        '''
+        Determines whether exp1 is, or might be, numerically less than exp2.
+
+        :param exp1: the first expression for the comparison.
+        :type exp1: :py:class:`psyclone.psyir.nodes.Node`
+        :param exp1: the second expression for the comparison.
+        :type exp1: :py:class:`psyclone.psyir.nodes.Node`
+        :param Optional[bool] all_variables_positive: whether or not to assume
+            that all variables appearing in either expression are positive
+            definite. Default is not to make this assumption.
+
+        :returns: whether exp1 is, or might be, numerically less than exp2.
+        :rtype: :py:class:`psyclone.core.symbolic_maths.Fuzzy`
+
+        '''
+        diff_val = SymbolicMaths._subtract(
+            exp1, exp2,
+            all_variables_positive=all_variables_positive)
+        if isinstance(diff_val, core.numbers.Integer):
+            if diff_val.is_zero or diff_val.is_positive:
+                return SymbolicMaths.Fuzzy.FALSE
+            return SymbolicMaths.Fuzzy.TRUE
+
+        # We have some sort of symbolic result
+        result = diff_val.is_negative
+        if result is None:
+            return SymbolicMaths.Fuzzy.MAYBE
+        if result:
+            return SymbolicMaths.Fuzzy.TRUE
+        return SymbolicMaths.Fuzzy.FALSE
+
     # -------------------------------------------------------------------------
     @staticmethod
     def solve_equal_for(exp1, exp2, symbol):

src/psyclone/psyir/nodes/node.py

@@ -1782,6 +1782,23 @@ def update_parent_symbol_table(self, new_parent):
 
         '''
 
+    def is_descendent_of(self, potential_ancestor) -> bool:
+        '''
+        Checks if this node is a descendant of the `potential_ancestor` node.
+
+        :param potential_ancestor: The Node to check whether its an ancestor
+                                   of self.
+        :type node: :py:class:`psyclone.psyir.nodes.Node`
+
+        :returns: whether potential_ancestor is an ancestor of this node.
+        '''
+        current_node = self
+        while (current_node is not potential_ancestor and
+               current_node.parent is not None):
+            current_node = current_node.parent
+
+        return current_node is potential_ancestor
+
 
 # For automatic documentation generation
 # TODO #913 the 'colored' routine shouldn't be in this module.

src/psyclone/psyir/nodes/reference.py

@@ -102,10 +102,18 @@ def is_read(self):
         '''
         # pylint: disable=import-outside-toplevel
         from psyclone.psyir.nodes.assignment import Assignment
+        from psyclone.psyir.nodes.intrinsic_call import IntrinsicCall
         parent = self.parent
         if isinstance(parent, Assignment):
             if parent.lhs is self:
                 return False
+
+        # If we have an intrinsic call parent then we need to check if its
+        # an inquiry. Inquiry functions don't read from their first argument.
+        if isinstance(parent, IntrinsicCall):
+            if parent.arguments[0] is self and parent.is_inquiry:
+                return False
+
         # All references other than LHS of assignments represent a read. This
         # can be improved in the future by looking at Call intents.
         return True

src/psyclone/psyir/tools/definition_use_chains.py

@@ -250,16 +250,20 @@ def find_forward_accesses(self):
                         .abs_position
                         + 1
                     )
-                    # We make a copy of the reference to have a detached
-                    # node to avoid handling the special cases based on
-                    # the parents of the reference.
-                    chain = DefinitionUseChain(
-                        self._reference.copy(),
-                        body,
-                        start_point=ancestor.abs_position,
-                        stop_point=sub_stop_point,
-                    )
-                    chains.insert(0, chain)
+                    # If we have a basic block with no children then skip it,
+                    # e.g. for an if block with no code before the else
+                    # statement, as is found in NEMO4.
+                    if len(body) > 0:
+                        # We make a copy of the reference to have a detached
+                        # node to avoid handling the special cases based on
+                        # the parents of the reference.
+                        chain = DefinitionUseChain(
+                            self._reference.copy(),
+                            body,
+                            start_point=ancestor.abs_position,
+                            stop_point=sub_stop_point,
+                        )
+                        chains.insert(0, chain)
                     # If its a while loop, create a basic block for the while
                     # condition.
                     if isinstance(ancestor, WhileLoop):
@@ -300,6 +304,11 @@ def find_forward_accesses(self):
             # Now add all the other standardly handled basic_blocks to the
             # list of chains.
             for block in basic_blocks:
+                # If we have a basic block with no children then skip it,
+                # e.g. for an if block with no code before the else
+                # statement, as is found in NEMO4.
+                if len(block) == 0:
+                    continue
                 chain = DefinitionUseChain(
                     self._reference,
                     block,
@@ -449,6 +458,12 @@ def _compute_forward_uses(self, basic_block_list):
                     if defs_out is not None:
                         self._defsout.append(defs_out)
                     return
+                # If its parent is an inquiry function then its neither
+                # a read nor write if its the first argument.
+                if (isinstance(reference.parent, IntrinsicCall) and
+                        reference.parent.is_inquiry and
+                        reference.parent.arguments[0] is reference):
+                    continue
                 if isinstance(reference, CodeBlock):
                     # CodeBlocks only find symbols, so we can only do as good
                     # as checking the symbol - this means we can get false
@@ -525,9 +540,7 @@ def _compute_forward_uses(self, basic_block_list):
                             if defs_out is None:
                                 self._uses.append(reference)
                     elif reference.ancestor(Call):
-                        # It has a Call ancestor so assume read/write access
-                        # for now.
-                        # We can do better for IntrinsicCalls realistically.
+                        # Otherwise we assume read/write access for now.
                         if defs_out is not None:
                             self._killed.append(defs_out)
                         defs_out = reference
@@ -699,6 +712,12 @@ def _compute_backward_uses(self, basic_block_list):
                 abs_pos = reference.abs_position
                 if abs_pos < self._start_point or abs_pos >= stop_position:
                     continue
+                # If its parent is an inquiry function then its neither
+                # a read nor write if its the first argument.
+                if (isinstance(reference.parent, IntrinsicCall) and
+                        reference.parent.is_inquiry and
+                        reference.parent.arguments[0] is reference):
+                    continue
                 if isinstance(reference, CodeBlock):
                     # CodeBlocks only find symbols, so we can only do as good
                     # as checking the symbol - this means we can get false
@@ -784,9 +803,7 @@ def _compute_backward_uses(self, basic_block_list):
                             if defs_out is None:
                                 self._uses.append(reference)
                     elif reference.ancestor(Call):
-                        # It has a Call ancestor so assume read/write access
-                        # for now.
-                        # We can do better for IntrinsicCalls realistically.
+                        # Otherwise we assume read/write access for now.
                         if defs_out is not None:
                             self._killed.append(defs_out)
                         defs_out = reference
@@ -835,6 +852,11 @@ def find_backward_accesses(self):
             # Now add all the other standardly handled basic_blocks to the
             # list of chains.
             for block in basic_blocks:
+                # If we have a basic block with no children then skip it,
+                # e.g. for an if block with no code before the else
+                # statement, as is found in NEMO4.
+                if len(block) == 0:
+                    continue
                 chain = DefinitionUseChain(
                     self._reference,
                     block,
@@ -874,14 +896,18 @@ def find_backward_accesses(self):
                         ).abs_position
                     else:
                         sub_start_point = self._reference.abs_position
-                    chain = DefinitionUseChain(
-                        self._reference.copy(),
-                        body,
-                        start_point=sub_start_point,
-                        stop_point=sub_stop_point,
-                    )
-                    chains.append(chain)
-                    control_flow_nodes.append(ancestor)
+                    # If we have a basic block with no children then skip it,
+                    # e.g. for an if block with no code before the else
+                    # statement, as is found in NEMO4.
+                    if len(body) > 0:
+                        chain = DefinitionUseChain(
+                            self._reference.copy(),
+                            body,
+                            start_point=sub_start_point,
+                            stop_point=sub_stop_point,
+                        )
+                        chains.append(chain)
+                        control_flow_nodes.append(ancestor)
                     # If its a while loop, create a basic block for the while
                     # condition.
                     if isinstance(ancestor, WhileLoop):

src/psyclone/psyir/transformations/__init__.py

@@ -105,6 +105,8 @@
      ReplaceInductionVariablesTrans
 from psyclone.psyir.transformations.reference2arrayrange_trans import \
     Reference2ArrayRangeTrans
+from psyclone.psyir.transformations.scalarization_trans import \
+    ScalarizationTrans
 
 
 # For AutoAPI documentation generation
@@ -145,5 +147,6 @@
            'Reference2ArrayRangeTrans',
            'RegionTrans',
            'ReplaceInductionVariablesTrans',
+           'ScalarizationTrans',
            'TransformationError',
            'ValueRangeCheckTrans']