cuda fortran speed-up - cuda

Question

I am trying to evaluate the speed-up of a simple cuda fortran code: increment of an array.
CPU version:
module simpleOps_m
contains
subroutine increment (a, b)
implicit none
integer , intent ( inout ) :: a(:)
integer , intent (in) :: b
integer :: i, n
n = size (a)
do i = 1, n
a(i) = a(i)+b
enddo
end subroutine increment
end module simpleOps_m
program incrementTest
use simpleOps_m
implicit none
integer , parameter :: n = 1024*1024*100
integer :: a(n), b
a = 1
b = 3
call increment (a, b)
if ( any(a /= 4)) then
write (* ,*) '**** Program Failed **** '
else
write (* ,*) 'Program Passed '
endif
end program incrementTest
GPU version:
module simpleOps_m
contains
attributes ( global ) subroutine increment (a, b)
implicit none
integer , intent ( inout ) :: a(:)
integer , value :: b
integer :: i, n
n = size (a)
do i=blockDim %x*( blockIdx %x -1) + threadIdx %x ,n, BlockDim %x* GridDim %x
a(i) = a(i)+b
end do
end subroutine increment
end module simpleOps_m
program incrementTest
use cudafor
use simpleOps_m
implicit none
integer , parameter :: n = 1024*1024*100
integer :: a(n), b
integer , device :: a_d(n)
integer :: tPB = 256
a = 1
b = 3
a_d = a
call increment <<< 128,tPB >>>(a_d , b)
a = a_d
if ( any(a /= 4)) then
write (* ,*) '**** Program Failed **** '
else
write (* ,*) 'Program Passed '
endif
end program incrementTest
So I compile both versions with pgf90
http://www.pgroup.com/resources/cudafortran.htm
Using "time" command to evaluate execution time, I obtain:
for CPU version
$ time (cpu executable)
real 0m0.715s
user 0m0.410s
sys 0m0.300s
for GPU version
$ time (gpu executable)
real 0m1.057s
user 0m0.710s
sys 0m0.340s
So the speed-up=(CPU exec.time)/(GPU exec.time) is < 1
Are there some reason why the speed-up is not > 1 as one should attain?
Thanks in advance

Answer 1

The problem here is that in this rather contrived example, the cost of initialising the large array on the host (a=1) is almost the same as the cost of loop to increment the array contents, which is the part of the code being parallelised on the GPU. Because the total amount of parallel work is about the same as the total amount of serial work, Amdahl's Law is heavily stacked against achieving any sort of significant speed up by parallelising some of the code on the GPU.
A more significant speed up could probably be achieved by fusing the initialisation and increment operations into a single parallel operation on the GPU.
[This answer has been assembled from comments and added as a community wiki entry to get this question off the unanswered list for the CUDA tag]