I want to test the optimization of `do concurrent`

in NVFortran. I generated a vector dot product program using ChatGPT, and when `n <= 10^7`

, the results for the first few elements are normal. However, when I set the array length to `10^8`

, there is an issue with the initialization of array `y`

. The first few elements are all `100000000`

. Since `integer*8`

type is used, overflow is clearly not the issue. On the other hand, when using an array constructor expression for initialization `yy`

, the results are normal. I used gfortran version 9.4 with the compilation command `gfortran test.f90`

.

```
program optimization_example
implicit none
integer(kind=8), parameter :: n = 100000000
integer(kind=8) :: x(n), y(n), z(n)
integer(kind=8) :: i
real(kind=8) :: t1,t2
call cpu_time(t1)
! Initialize arrays
call initialize_arrays(x, y, n)
! Compute z = x * y using loop unrolling and data locality
! Using DO CONCURRENT for parallel execution
do concurrent(i = 1:n)
z(i) = x(i) * y(i)
end do
! Print a few results to check
call cpu_time(t2)
write(*,*) t2-t1
print *, 'x=',x(1:10)
print *, 'y=', y(1:10)
print *, 'z=', z(1:10)
end program optimization_example
subroutine initialize_arrays(x, y, n)
implicit none
integer(kind=8) :: n
integer(kind=8), dimension(n) :: x, y,yy
integer(kind=8) :: i
! Initialize arrays with some values
do i = 1, n
x(i) = real(i)
y(i) = real(n - i)
end do
yy=[(n-i, i=1,n)]
print *, 'init_x=',x(1:10)
print *, 'init_y=', y(1:10)
print *, 'init_yy=', yy(1:10)
end subroutine initialize_arrays
```

The results are as follows:

init_y= 100000000 100000000 100000000 100000000 99999992 99999992 99999992 99999992 99999992 99999992

init_yy= 99999999 99999998 99999997 99999996 99999995 99999994 99999993 99999992 99999991 99999990