Changes for review

Author: LonelyCat124

src/psyclone/psyir/transformations/maximal_region_trans.py

@@ -175,7 +175,8 @@ def _compute_transformable_sections(
                 # Test validation for the whole region, and if successful
                 # then we can finish.
                 trans.validate(n_list)
-                all_blocks.append(n_list)
+                if self._satisfies_minimum_region_rules(n_list):
+                    all_blocks.append(n_list)
                 return all_blocks
             except TransformationError:
                 pass

src/psyclone/tests/psyir/transformations/maximal_region_trans_test.py

@@ -45,6 +45,7 @@
     Routine,
     Loop,
     OMPParallelDirective,
+    Node,
 )
 from psyclone.psyir.transformations import (
     MaximalRegionTrans,
@@ -386,3 +387,67 @@ def test_apply_force_private(fortran_reader):
     assert isinstance(nodes[0], OMPParallelDirective) is True
     pdir = nodes[0]
     assert len(pdir.explicitly_private_symbols) == 5
+
+
+def test_full_region_doesnt_meet_minimum_rules_compute_transformable_section(
+    fortran_reader
+):
+    '''Test that if the full region validates but doesn't meet the
+    requirements for _satisfies_minimum_region_rules then the returned
+    list is empty.'''
+    code = """subroutine x
+    integer :: i, ii, k, l, block
+    integer :: array_l(8)
+    block = 2
+    do ii = 1, 4
+        do k = 4, 1, -1
+            l = 0
+            do i = ii, min(ii+block -1, 4)
+                l = l + 1
+                array_l(l) = 1 + 2
+            end do
+        end do
+    end do
+    end subroutine x
+    """
+    psyir = fortran_reader.psyir_from_source(code)
+    # Apply loop_trans to all the loops possible.
+    ltrans = OMPLoopTrans(omp_schedule="static")
+    ltrans.apply(
+        psyir.walk(Loop)[0],
+        ignore_dependencies_for=["array_l"],
+        nowait=True)
+
+    # Create a transformation that always validates correctly
+    class testTrans(Transformation):
+        '''Dummy transformation that never fails validation.'''
+
+        def validate(self, nodes, **kwargs):
+            pass
+
+        def apply(self, nodes, **kwargs):
+            pass
+
+    # Create a region transformation that has a custom
+    # _satisfies_minimum_region_rules function that the
+    # input code will fail.
+    class TestRegTrans(MaximalRegionTrans):
+        ''' Dummy class to test MaxParallelRegionTrans' functionality. '''
+        # The apply function will do OMPParallelTrans around allowed regions.
+        _transformation = testTrans
+        _SUB_TRANSFORMATIONS = [testTrans]
+        # We're allowing any Node.
+        _allowed_contiguous_statements = (Node, )
+        # Should parallelise any found region.
+        _required_nodes = (Node, )
+
+        def _satisfies_minimum_region_rules(self, node_list):
+            ''' Arbitrarily the node list needs to be size 100 for this
+            MaximalRegionTrans.'''
+            return len(node_list) > 100
+
+    mtrans = TestRegTrans()
+    routine = psyir.walk(Routine)[0]
+    rval = mtrans._compute_transformable_sections(routine.children[:],
+                                                  testTrans(), {})
+    assert len(rval) == 0