Merge pull request #281 from sourceryinstitute/convert-test-hang-to-fail

set ctest to time-out on failing alloc comp test

Author: Damian Rouson

CMakeLists.txt

@@ -356,6 +356,7 @@ endfunction(add_mpi_test)
 
 set(tests_root ${CMAKE_CURRENT_BINARY_DIR}/src/tests)
 
+
 if(opencoarrays_aware_compiler)
   # Unit tests targeting each libcaf_mpi function, argument, and branch of code
   add_mpi_test(initialize_mpi 2 ${tests_root}/unit/init_register/initialize_mpi)
@@ -368,7 +369,9 @@ if(opencoarrays_aware_compiler)
     add_mpi_test(register_alloc_comp_1 2 ${tests_root}/unit/init_register/register_alloc_comp_1)
     add_mpi_test(register_alloc_comp_2 2 ${tests_root}/unit/init_register/register_alloc_comp_2)
     add_mpi_test(register_alloc_comp_3 2 ${tests_root}/unit/init_register/register_alloc_comp_3)
-    add_mpi_test(check_remote_alloced_comp_1 6 ${tests_root}/unit/init_register/check_remote_alloced_comp_1)
+    add_mpi_test(async_comp_alloc 6 ${tests_root}/unit/init_register/async_comp_alloc)
+    # Timeout async_comp_alloc test after 3 seconds to progess past the known failure
+    set_property(TEST async_comp_alloc PROPERTY TIMEOUT_AFTER_MATCH 3 "known failure")
   endif()
   add_mpi_test(get_array 2 ${tests_root}/unit/send-get/get_array)
   add_mpi_test(get_self 2 ${tests_root}/unit/send-get/get_self)

src/tests/unit/init_register/CMakeLists.txt

@@ -17,8 +17,8 @@ add_executable(allocate_as_barrier_proc allocate_as_barrier_proc.f90)
 target_link_libraries(allocate_as_barrier_proc OpenCoarrays)
 
 if (gfortran_compiler AND (NOT CMAKE_Fortran_COMPILER_VERSION VERSION_LESS 7))
-  add_executable(check_remote_alloced_comp_1 check_remote_alloced_comp_1.f90)
-  target_link_libraries(check_remote_alloced_comp_1 OpenCoarrays)
+  add_executable(async_comp_alloc async_comp_alloc.f90)
+  target_link_libraries(async_comp_alloc OpenCoarrays)
 
   add_executable(register_alloc_comp_1 register_alloc_comp_1.f90)
   target_link_libraries(register_alloc_comp_1 OpenCoarrays)

src/tests/unit/init_register/async_comp_alloc.f90

@@ -0,0 +1,121 @@
+! async_comp_alloc.f90 
+
+! Unit test for register procedure and remote allocated test:
+! Test that scalar allocatable component in a derived typed coarray is
+! registered correctly, its allocation is deferred until the program
+! allocates it specifically, and it is deregisterable. The component 
+! allocation checks are done on remote images.
+!
+! Copyright (c) 2012-2016, Sourcery, Inc.
+! All rights reserved.
+!
+! Redistribution and use in source and binary forms, with or without
+! modification, are permitted provided that the following conditions are met:
+!     * Redistributions of source code must retain the above copyright
+!       notice, this list of conditions and the following disclaimer.
+!     * Redistributions in binary form must reproduce the above copyright
+!       notice, this list of conditions and the following disclaimer in the
+!       documentation and/or other materials provided with the distribution.
+!     * Neither the name of the Sourcery, Inc., nor the
+!       names of its contributors may be used to endorse or promote products
+!       derived from this software without specific prior written permission.
+!
+! THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+! ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+! WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+! DISCLAIMED. IN NO EVENT SHALL SOURCERY, INC., BE LIABLE FOR ANY
+! DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+! (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+! LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+! ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+! (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+! SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+program async_comp_alloc
+  implicit none
+
+  type dt
+    integer, allocatable :: i
+  end type dt
+  type(dt), allocatable :: obj[:]
+    !! Container object for testing component allocation status
+
+  logical, parameter :: verbose=.true. 
+    !! Toggle verbose output for debugging purposes
+
+  integer :: allocation_status
+  integer, parameter :: success=0
+    !! Successful allocation status value
+
+
+  associate(me=>this_image(),np=>num_images())
+    !! Make me & np locally immutable by associating them with function results
+
+    call assert( np > 1, "num_images()>1")
+      !! Ensure at least two images to simplify the test 
+
+    allocate(obj[*],stat=allocation_status)
+      !! Allocate only the container. obj%i must not be allocated hereafter.
+
+    call assert(allocation_status == success, "allocated(obj)")
+    call assert(.not. allocated(obj%i)      , ".not. allocated(obj%i)")
+
+    if (me==1) print *,"known failure -- ctest will timeout (see https://github.com/sourceryinstitute/opencoarrays/issues/260)."
+
+    block 
+      integer :: allocating_image, test_image
+      character(len=8) :: image_number
+
+      loop_over_all_image_numbers: do allocating_image = 1, np
+        !! Check that all allocations have been performed up to allocating_image and
+        !! that no other allocations have been performed
+  
+        if (verbose) print *, me, "/", np, ": allocating_image=", allocating_image
+  
+        if (allocating_image /= me) then
+          sync all
+           !! Order allocations sequentially by image number: arrival of image 'allocating_image' 
+           !! at the sync all in the alternate branch launches the following test loop.
+          test_allocation_status: do test_image = 1, np
+            if (verbose) print *, me, "/", np, ": Checking", test_image, " for allocation status."
+            write(image_number,*) test_image
+            if (test_image <= allocating_image) then
+              call assert(allocated(obj[test_image]%i), " allocated(obj["//image_number//"]%i)" )
+                !! Enforce that image numbers up to mine have allocated their components
+            else
+              call assert(.not. allocated(obj[test_image]%i), ".not. allocated(obj["//image_number//"]%i) on image ")
+                !! Enforce that image numbers higher than 'image' should not have allocated their components yet
+            end if
+          end do test_allocation_status 
+        else
+          if (verbose) print *, me, "/", np, ": allocating..."
+          allocate(obj%i, source = me)
+            !! TODO: should we also ensure that implicit (re)allocation upon assignment works here?
+          if (verbose) print *, me, "/", np, ": allocated"
+          ! Enforce that object has been allocated and obj%i is this_image():
+          call assert( allocated(obj)  , "allocated(obj)")
+          call assert( allocated(obj%i), "allocated(obj%i)")
+          call assert( obj%i == me     , "obj%i == this_image()")
+          sync all
+        end if
+      end do loop_over_all_image_numbers
+    end block
+  end associate
+contains
+  subroutine assert(assertion,description,stat)
+    logical, intent(in) :: assertion 
+    character(len=*), intent(in) :: description
+    integer, intent(out), optional:: stat
+    integer, parameter :: failure=1
+    if (assertion) then
+       if (present(stat)) stat=success
+    else
+      if (present(stat)) then
+        stat=failure
+      else
+        error stop "Assertion "// description //" failed."
+      end if
+    end if
+  end subroutine
+end program
+