This subroutine (calculate_idle_processes) is used to calculate the difference between the number of processes used in the xxf and yxf data layouts. This is important as it can affect the amount of communication that the code has to undertake when moving between linear and non-linear calculations.
This routine is used by ingen when it is suggesting optimal process counts for users to flag up when suggested process counts will results in there being a significant difference in the processes used in the two layouts, and therefore a significant communication overhead moving between the two layouts.
AJ, November 2011: New code from DCSE project
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer, | intent(in) | :: | nprocs | |||
| real, | intent(out) | :: | idle_percentage |
subroutine calculate_idle_processes(nprocs, idle_percentage)
implicit none
integer, intent(in) :: nprocs
real, intent(out) :: idle_percentage
integer :: xxf_blocksize, yxf_blocksize
real :: xxf_usedprocs, xxf_idleprocs
real :: yxf_usedprocs, yxf_idleprocs
real :: delta_idle_procs
! Ensure that the xxf_lo% and yxf_lo%data has been properly initialized as this
! routine relies on some data from those data structures. If it has not
! then abort this routine.
if(.not. initialized_x_transform .and. .not. initialized_y_transform) then
write(*,*) 'X and/or Y transform data structures not initialized so calculate_idle_processes will not operate correctly'
write(*,*) 'Aborting subroutine calculate_idle_processes'
return
end if
if(nprocs .lt. 1) then
write(*,*) 'nprocs value in calculate_idle_processes subroutine is less than 1 which is incorrect.'
write(*,*) 'calculate_idle_processes aborting.'
return
end if
! Calculate the standard xxf_blocksize
xxf_blocksize = xxf_lo%ulim_world/nprocs + 1
! Use the blocksize calculated above to calculate how many processes the
! xxf space maps to using this block size
xxf_usedprocs = (xxf_lo%ulim_world+1)/real(xxf_blocksize)
! Now work out how many processes do not have any xxf data space assigned
! to them. This is calculated using real arthimetic so it will also
! include partial data spaces (so for instance it will calculate where
! a process only has half a block assigned to it).
xxf_idleprocs = nprocs - xxf_usedprocs
! Calculate the standard yxf_blocksize
yxf_blocksize = yxf_lo%ulim_world/nprocs + 1
! Use the blocksize calculated above to calculate how many processes the
! yxf space maps to using this block size
yxf_usedprocs = (yxf_lo%ulim_world+1)/real(yxf_blocksize)
! Now work out how many processes do not have any yxf data space assigned
! to them. This is calculated using real arthimetic so it will also
! include partial data spaces (so for instance it will calculate where
! a process only has half a block assigned to it).
yxf_idleprocs = nprocs - yxf_usedprocs
! Calculate the difference between the idle processes in the yxf and xxf
! decompositions. A high delta_idle_procs will cause high communication
! costs in the transform routines.
delta_idle_procs = abs(yxf_idleprocs - xxf_idleprocs)
! Roughly calculate the percentage of data to be transferred in the
! transform between the xxf and yxf data spaces using the delta_idle_procs
! variable calculated above.
if ( delta_idle_procs .le. 1 ) then
idle_percentage = 0.5d0 * delta_idle_procs
else
idle_percentage = (1.0d0 - 1.0d0/(2.0d0 * delta_idle_procs))
end if
end subroutine calculate_idle_processes