Add tests for block partitioning with singletons

Check that block partitioning works even in the presence of
singletons.

Author: zbeekman

test/data_partition_test.f90

@@ -27,9 +27,19 @@ function results() result(test_results)
     type(test_result_t), allocatable :: test_results(:)
 
     test_results = [ &
-      test_result_t("partitioning data in nearly even blocks", verify_block_partitioning()), &
+      test_result_t("partitioning data in nearly even blocks", verify_block_partitioning(num_particles)), &
+      test_result_t("partitioning data in nearly even blocks when some blocks are singletons", &
+       verify_block_partitioning(num_images()+1)), &
+      test_result_t("bins of size 1 when set cardinality == num_images()", verify_block_partitioning_with_singletons()), &
       test_result_t("default image_number is this_image()", verify_default_image_number()), &
+      test_result_t("partitioning data into contiguous bins without overlap", &
+        verify_partitions_are_contiguous_without_overlap(num_particles)), &
+      test_result_t("contiguous non overlapping partitions with singletons", &
+        verify_partitions_are_contiguous_without_overlap(num_images())), &
+      test_result_t("contiguous non overlapping partitions with some singletons", &
+        verify_partitions_are_contiguous_without_overlap(num_images()+1)), &
       test_result_t("partitioning all data across all images without data loss", verify_all_particles_partitioned()), &
+      test_result_t("no data is lost when singleton bins are used", verify_all_particles_partitioned_on_singletons()), &
       test_result_t("gathering a 1D real array onto all images", verify_all_gather_1D_real_array()), &
       test_result_t("gathering dimension 1 of 2D real array onto all images witout dim argument", &
         verify_all_gather_2D_real_array()), &
@@ -40,26 +50,96 @@ function results() result(test_results)
     ]
   end function
 
-  function verify_block_partitioning() result(test_passes)
+  function verify_testing_in_parallel() result(test_passes)
+    !! Verify that the test is being run in parallel
+    logical test_passes
+    test_passes = num_images() > 1
+  end function
+
+  function verify_block_partitioning(cardinality) result(test_passes)
     !! Verify that the data is partitioned across images evenly to
     !! within a difference of one datum between any two images.
+    integer, intent(in) :: cardinality
     type(data_partition_t) partition
     logical test_passes
     integer my_particles
 
+    associate( me=>this_image(), partition => data_partition_t(cardinality=cardinality))
+      associate( my_first=>partition%first(me), my_last=>partition%last(me) )
+        my_particles = my_last - my_first + 1
+        associate( ni=>num_images() )
+          associate( quotient=>cardinality/ni, remainder=>mod(cardinality,ni)  )
+            test_passes = quotient + merge(1, 0, me<=remainder) == my_particles
+          end associate
+        end associate
+      end associate
+    end associate
+
+  end function
+
+  function verify_block_partitioning_with_singletons() result(test_passes)
+    !! Verify that the data is partitioned so that each image has a bin of
+    !! size 1.
+    type(data_partition_t) partition, another_partition
+    logical test_passes
+    integer my_particles
+    integer num_particles
+        
+    num_particles = num_images()
+    another_partition = data_partition_t(cardinality=num_particles)
+
     associate( me=>this_image(), partition => data_partition_t(cardinality=num_particles))
       associate( my_first=>partition%first(me), my_last=>partition%last(me) )
         my_particles = my_last - my_first + 1
         associate( ni=>num_images() )
           associate( quotient=>num_particles/ni, remainder=>mod(num_particles,ni)  )
-            test_passes = quotient + merge(1, 0, me<=remainder) == my_particles
+            test_passes = quotient == 1 &
+              .and. remainder == 0 &
+              .and. my_particles == 1 &
+              .and. my_last == my_first &
+              .and. my_first == me
           end associate
         end associate
       end associate
     end associate
 
   end function
 
+  function verify_partitions_are_contiguous_without_overlap(cardinality) result(test_passes)
+    !! Verify that the data is partitioned across images into contiguous bins without overlap
+    integer, intent(in) :: cardinality
+    logical test_passes
+    type(data_partition_t) partition
+
+    associate( me=>this_image(), partition => data_partition_t(cardinality=cardinality))
+      associate( my_first=>partition%first(me), my_last=>partition%last(me) )
+        associate(ni => num_images())
+          if (me > 1) then
+            associate( your_first=>partition%first(me-1), your_last=>partition%last(me-1) )
+                test_passes = my_first <= my_last &
+                .and. your_first <= your_last &
+                .and. my_first >= 1 &
+                .and. my_last <= cardinality &
+                .and. my_first == your_last + 1
+            end associate
+          else if (me == 1 .and. ni > 1) then
+            associate( your_first=>partition%first(me+1), your_last=>partition%last(me+1) )
+                test_passes = my_first <= my_last &
+                .and. your_first <= your_last &
+                .and. my_first >= 1 &
+                .and. my_last <= cardinality &
+                .and. my_last == your_first - 1
+            end associate
+          else if (ni == 1) then
+            test_passes = my_first <= my_last &
+            .and. my_first >= 1 &
+            .and. my_last <= cardinality
+          end if
+        end associate
+      end associate
+    end associate
+  end function
+
   function verify_default_image_number() result(test_passes)
     !! Verify that the first and last functions assume image_number == this_image() if image_number is not  present
     type(data_partition_t) partition
@@ -86,6 +166,26 @@ function verify_all_particles_partitioned() result(test_passes)
     end associate
   end function
 
+  function verify_all_particles_partitioned_on_singletons() result(test_passes)
+    !! Verify that the number of particles on each image sums to the
+    !! total number of particles distributed when the cardinality of the 
+    !! partitioned set is equal to num_images()
+    type(data_partition_t) partition
+    logical test_passes
+    integer particles
+    integer num_particles
+    num_particles = num_images()
+
+    associate( me=>this_image(), partition => data_partition_t(cardinality=num_particles))
+      associate( my_first=>partition%first(me), my_last=>partition%last(me) )
+        particles = my_last - my_first + 1
+        test_passes = particles == 1
+        call co_sum(particles)
+        test_passes = test_passes .and. num_particles == particles
+      end associate
+    end associate
+  end function
+
  function verify_all_gather_1D_real_array() result(test_passes)
    type(data_partition_t) partition
    logical test_passes