Update interface of prif_num_images based on latest design doc

choices.

example/hello.f90

@@ -2,12 +2,13 @@ program hello_world
   use prif, only : prif_init, this_image => prif_this_image, num_images => prif_num_images, prif_stop
   implicit none
 
-  integer :: me
+  integer :: me, num_imgs
 
   if (prif_init() /= 0) error stop "caffeinate returned a non-zero exit code"
 
   call this_image(image_index=me)
-  print *, "Hello from image", me, "of", num_images()
+  call num_images(image_count=num_imgs)
+  print *, "Hello from image", me, "of", num_imgs
 
   call prif_stop(stop_code_int=0) ! normal termination
 

src/caffeine/image_enumeration_m.f90

@@ -10,19 +10,14 @@ module image_enumeration_m
   public :: prif_num_images
   public :: prif_this_image
 
-  interface prif_num_images
-
-    module function num_images_team(team) result(image_count)
-      implicit none
-      type(prif_team_type), intent(in), optional :: team
-      integer image_count
-    end function
-
-    module function num_images_team_number(team_number) result(image_count)
-      implicit none
-      integer, intent(in) :: team_number
-      integer image_count
-    end function
+  interface
+
+     module subroutine prif_num_images(team, team_number, image_count)
+       implicit none
+       type(prif_team_type), intent(in), optional :: team
+       integer(c_intmax_t), intent(in), optional :: team_number
+       integer(c_int), intent(out) :: image_count
+     end subroutine prif_num_images
 
   end interface
 

src/caffeine/image_enumeration_s.f90

@@ -6,13 +6,11 @@
 
 contains
 
-  module procedure num_images_team
+  module procedure prif_num_images
+    ! TODO: handle optional args `team` and `team_number`
     image_count = caf_num_images()
   end procedure
 
-  module procedure num_images_team_number
-  end procedure
-
   module procedure prif_this_image_no_coarray
     ! TODO: handle optional arg `team`
     image_index = caf_this_image()

test/caf_co_broadcast_test.f90

@@ -53,18 +53,14 @@ function broadcast_default_integer_scalar() result(result_)
   function broadcast_derived_type() result(result_)
     type(result_t) result_
     type(object_t) object
-    integer :: me
+    integer :: me, ni
 
     call prif_this_image(image_index=me)
-    associate(ni => prif_num_images())
-
-     object = object_t(me, .false., "gooey", me*(1.,0.))
-
-      call prif_co_broadcast(object, source_image=ni)
-
-      associate(expected_object => object_t(ni, .false., "gooey", ni*(1.,0.)))
-        result_ = assert_that(expected_object == object, "co_broadcast derived type")
-      end associate
+    call prif_num_images(image_count=ni)
+    object = object_t(me, .false., "gooey", me*(1.,0.))
+    call prif_co_broadcast(object, source_image=ni)
+    associate(expected_object => object_t(ni, .false., "gooey", ni*(1.,0.)))
+      result_ = assert_that(expected_object == object, "co_broadcast derived type")
     end associate
 
   end function

test/caf_co_max_test.f90

@@ -1,5 +1,5 @@
 module caf_co_max_test
-    use prif, only : prif_co_max, prif_num_images
+    use prif, only : prif_co_max
     use veggies, only: result_t, test_item_t, assert_equals, describe, it, assert_that, assert_equals
     use image_enumeration_m, only : prif_this_image, prif_num_images
 
@@ -40,38 +40,41 @@ function max_c_int64_scalars() result(result_)
         use iso_c_binding, only : c_int64_t
         type(result_t) result_
         integer(c_int64_t) i
-        integer :: me
+        integer :: me, num_imgs
 
         call prif_this_image(image_index=me)
         i = me
         call prif_co_max(i)
-        result_ = assert_equals(prif_num_images(), int(i))
+        call prif_num_images(image_count=num_imgs)
+        result_ = assert_equals(num_imgs, int(i))
     end function
 
     function max_default_integer_1D_array() result(result_)
         type(result_t) result_
-        integer i, me
+        integer i, me, num_imgs
         integer, allocatable :: array(:)
 
         call prif_this_image(image_index=me)
-        associate(sequence_ => me*[(i, i=1, prif_num_images())])
+        call prif_num_images(image_count=num_imgs)
+        associate(sequence_ => me*[(i, i=1, num_imgs)])
           array = sequence_
           call prif_co_max(array)
-          associate(max_sequence => prif_num_images()*[(i, i=1, prif_num_images())])
+          associate(max_sequence => num_imgs*[(i, i=1, num_imgs)])
             result_ = assert_that(all(max_sequence == array))
           end associate
         end associate
     end function
 
     function max_default_integer_7D_array() result(result_)
         type(result_t) result_
-        integer array(2,1,1, 1,1,1, 2), status_, me
+        integer array(2,1,1, 1,1,1, 2), status_, me, num_imgs
 
         status_ = -1
         call prif_this_image(image_index=me)
         array = 3 + me
         call prif_co_max(array, stat=status_)
-        result_ = assert_that(all(array == 3+prif_num_images())) .and. assert_equals(0, status_)
+        call prif_num_images(image_count=num_imgs)
+        result_ = assert_that(all(array == 3+num_imgs)) .and. assert_equals(0, status_)
     end function
 
     function max_default_real_scalars() result(result_)
@@ -115,12 +118,13 @@ function max_elements_in_3D_string_arrays() result(result_)
       call prif_co_max(co_max_scramlet, result_image=1)
 
       block
-        integer j, delta_j
+        integer j, delta_j, num_imgs
         character(len=len(script)) expected_script(size(script)), expected_scramlet(size(scramlet,1),size(scramlet,2))
 
+        call prif_num_images(image_count=num_imgs)
         do j=1, size(script)
           expected_script(j) = script(j)
-          do delta_j = 1, max(prif_num_images()-1, size(script))
+          do delta_j = 1, max(num_imgs-1, size(script))
             associate(periodic_index => 1 + mod(j+delta_j-1, size(script)))
               expected_script(j) = max(expected_script(j), script(periodic_index))
             end associate
@@ -137,15 +141,16 @@ function reverse_alphabetize_default_character_scalars() result(result_)
       type(result_t) result_
       character(len=*), parameter :: words(*) = [character(len=len("loddy")):: "loddy","doddy","we","like","to","party"]
       character(len=:), allocatable :: my_word
-      integer :: me
+      integer :: me, num_imgs
 
       call prif_this_image(image_index=me)
       associate(periodic_index => 1 + mod(me-1,size(words)))
         my_word = words(periodic_index)
         call prif_co_max(my_word)
       end associate
 
-      associate(expected_word => maxval(words(1:min(prif_num_images(), size(words)))))
+      call prif_num_images(image_count=num_imgs)
+      associate(expected_word => maxval(words(1:min(num_imgs, size(words)))))
         result_ = assert_equals(expected_word, my_word)
       end associate
     end function

test/caf_co_min_test.f90

@@ -27,13 +27,14 @@ function test_prif_co_min() result(tests)
 
     function min_default_integer_scalars() result(result_)
         type(result_t) result_
-        integer i, status_, me
+        integer i, status_, me, num_imgs
 
         status_ = -1
         call prif_this_image(image_index=me)
         i = -me
         call prif_co_min(i, stat=status_)
-        result_ = assert_equals(-prif_num_images(), i) .and. assert_equals(0, status_)
+        call prif_num_images(image_count=num_imgs)
+        result_ = assert_equals(-num_imgs, i) .and. assert_equals(0, status_)
     end function
 
     function min_c_int64_scalars() result(result_)
@@ -50,53 +51,57 @@ function min_c_int64_scalars() result(result_)
 
     function min_default_integer_1D_array() result(result_)
         type(result_t) result_
-        integer i, me
+        integer i, me, num_imgs
         integer, allocatable :: array(:)
 
         call prif_this_image(image_index=me)
-        associate(sequence_ => me*[(i, i=1, prif_num_images())])
+        call prif_num_images(image_count=num_imgs)
+        associate(sequence_ => me*[(i, i=1, num_imgs)])
           array = sequence_
           call prif_co_min(array)
-          associate(min_sequence => [(i, i=1, prif_num_images())])
+          associate(min_sequence => [(i, i=1, num_imgs)])
             result_ = assert_that(all(min_sequence == array))
           end associate
         end associate
     end function
 
     function min_default_integer_7D_array() result(result_)
         type(result_t) result_
-        integer array(2,1,1, 1,1,1, 2), status_, me
+        integer array(2,1,1, 1,1,1, 2), status_, me, num_imgs
 
         status_ = -1
         call prif_this_image(image_index=me)
         array = 3 - me
         call prif_co_min(array, stat=status_)
-        result_ = assert_that(all(array == 3 - prif_num_images())) .and. assert_equals(0, status_)
+        call prif_num_images(image_count=num_imgs)
+        result_ = assert_that(all(array == 3 - num_imgs)) .and. assert_equals(0, status_)
     end function
 
     function min_default_real_scalars() result(result_)
         type(result_t) result_
         real scalar
         real, parameter :: pi = 3.141592654
-        integer status_, me
+        integer status_, me, num_imgs
 
         status_ = -1
         call prif_this_image(image_index=me)
         scalar = -pi*me
         call prif_co_min(scalar, stat=status_)
-        result_ = assert_equals(-dble(pi*prif_num_images()), dble(scalar) ) .and. assert_equals(0, status_)
+        call prif_num_images(image_count=num_imgs)
+        result_ = assert_equals(-dble(pi*num_imgs), dble(scalar) ) .and. assert_equals(0, status_)
     end function
 
     function min_double_precision_2D_array() result(result_)
         type(result_t) result_
         double precision, allocatable :: array(:,:)
         double precision, parameter :: tent(*,*) = dble(reshape(-[0,1,2,3,2,1], [3,2]))
-        integer :: me
+        integer :: me, num_imgs
 
         call prif_this_image(image_index=me)
         array = tent*dble(me)
         call prif_co_min(array)
-        result_ = assert_that(all(array==tent*prif_num_images()))
+        call prif_num_images(image_count=num_imgs)
+        result_ = assert_that(all(array==tent*num_imgs))
     end function
 
     function min_elements_in_2D_string_arrays() result(result_)
@@ -116,12 +121,13 @@ function min_elements_in_2D_string_arrays() result(result_)
       call prif_co_min(co_min_scramlet, result_image=1)
 
       block
-        integer j, delta_j
+        integer j, delta_j, num_imgs
         character(len=len(script)) expected_script(size(script)), expected_scramlet(size(scramlet,1),size(scramlet,2))
 
+        call prif_num_images(image_count=num_imgs)
         do j=1, size(script)
           expected_script(j) = script(j)
-          do delta_j = 1, min(prif_num_images()-1, size(script))
+          do delta_j = 1, min(num_imgs-1, size(script))
             associate(periodic_index => 1 + mod(j+delta_j-1, size(script)))
               expected_script(j) = min(expected_script(j), script(periodic_index))
             end associate
@@ -138,15 +144,16 @@ function alphabetically_1st_scalar_string() result(result_)
       type(result_t) result_
       character(len=*), parameter :: words(*) = [character(len=len("to party!")):: "Loddy","doddy","we","like","to party!"]
       character(len=:), allocatable :: my_word
-      integer :: me
+      integer :: me, num_imgs
 
       call prif_this_image(image_index=me)
       associate(periodic_index => 1 + mod(me-1,size(words)))
         my_word = words(periodic_index)
         call prif_co_min(my_word)
       end associate
 
-      associate(expected_word => minval(words(1:min(prif_num_images(), size(words)))))
+      call prif_num_images(image_count=num_imgs)
+      associate(expected_word => minval(words(1:min(num_imgs, size(words)))))
         result_ = assert_equals(expected_word, my_word)
       end associate
     end function