kiranchandramohan
commented
4 years ago Background Fortran assignment has the syntax variable = expr. Rules permit both variable and expr to reference any portion of the variable. The requirement is that the evaluation of expr should not be affected by the assignment to variable[1]. For e.g, If the initial value of an array ARR was set as (/1, 2, 3, 4, 5/) and if there is an array assignment ARR(2:5) = ARR(1:4) then the contents of array ARR should be (/1, 1, 2, 3, 4/) and not (/1, 1, 1, 1, 1/).
R1032 assignment-stmt is variable = expr10.2.1.34 Both variable and expr may contain references to any
portion of the variable.
NOTE 2 For example, in the character intrinsic assignment statement: STRING (2:5) = STRING (1:4)the
assignment of the first character of STRING to the second character does not affect the evaluation of
STRING (1:4). If the value of STRING prior to the assignment was ’ABCDEF’, the value following the
assignment is ’AABCDF’.Fortran compilers typically achieve this by inserting a temporary copy of the array for the expression on the RHS and then assign the variable from this temporary copy. So the code generated might look like the following. Note the temporary array created tmp_ARR. Unlike in the example below, typically this temporary is created on the heap.
integer :: ARR(5) = (/1, 2, 3, 4, 5/)
integer :: tmp_ARR(5)
integer :: i, j
do i=1,5
tmp_ARR(i) = ARR(i)
end do
j = 1
do i=2,5
ARR(i) = tmp_ARR(j)
j = j + 1
end doThe creation of the temporary on the heap and the copying involved can affect performance particularly if this happens inside a loop. So compilers try to optimize these temporaries away when they are not needed in situations like, 1) When there is no overlap between LHS and RHS. e.g: ARR(1:2) = ARR(3:5) 2) When there is full overlap between LHS and RHS. e.g: ARR(1:5) = ARR(1:5) + constant
These optimization require good dependence analysis. If the arrays involved are pointers then the dependence analysis task becomes even more difficult since pointers can alias. For the Fortran program given below gfortran does not have a temporary array and copy but Flang has.
subroutine cdata(n,dim1,val2,val1)
implicit none
integer :: n,dim1
real(4), pointer :: val2(:,:)
real(4), pointer :: val1(:)
integer :: i
do i=1,n
val2(1:dim1,i) = val2(1:dim1,i)*val1(i)
end do
end subroutine cdataThere is no temporary needed here since even if val1 aliases with val2, it does not affect the evaluation. The evaluation of the array assignment expression here depends only on a single value in val1, i.e. val1(i). As long as this value is read and stored in a register/temporary location, even if val1(i) is written into during the evaluation of the array assignment it is fine and the results do not change. For val2 the lhs and rhs refer to the same section and indices, so each element can be multiplied by val1(i) and updated in place without a temporary array.
val2(1:dim1,i) = val2(1:dim1,i)*val1(i)The backdoor flag, -Hx,4,0x100000, can be used to not add temporary arrays (by turning of dependence analysis for array-assignments/forall). But as expected some programs which need temporary arrays will not work correctly. For e.g. the following flang unit tests will fail.
Flang :: f90_correct/lit/ka65.sh
Flang :: f90_correct/lit/ka66.sh
Flang :: f90_correct/lit/ka67.sh
Flang :: f90_correct/lit/ka68.sh
Flang :: f90_correct/lit/ka69.shThe forall/array assignment dependence analysis should be improved to remove the requirement to add temporary arrays like in the subroutine cdata sample program given above. See code in tools/flang1/flang1exe/outconv.c.
if (!XBIT(4, 0x100000))
forall_dependency_analyze();
michalpasztamobica
mleair
pawosm-arm
Flang inserts a temporary array in the computation of the following code in the program given below.
val2(1:dim1,i) = val2(1:dim1,i)*val1(i)There is no temporary needed here since even if val1 aliases with val2, it does not affect the evaluation. The evaluation of the array assignment expression here depends only on a single value in val1, i.e. val1(i). As long as this value is read and stored in a register/temporary location, even if val1(i) is written into during the evaluation of the array assignment it is fine and the results do not change. For val2 the lhs and rhs refer to the same section and indices, so each element can be multiplied by val1(i) and updated in place without a temporary array.