[Flang] Defined assignments for derived types with derived type components are slower than GFortran

[yus3710-fj]

The execution of the following codes is slower than GFortran.

• test.f90

module d
  type mytype1
    integer :: x,y,z
  end type
  type mytype2
    integer :: x,y
    type(mytype1) :: t
  end type
  interface assignment(=)
    module procedure :: swap
  end interface

contains
  pure subroutine swap(lhs,rhs)
    type(mytype2), intent(in) :: rhs
    type(mytype2), intent(out) :: lhs
    lhs%x = rhs%y
    lhs%y = rhs%x
    lhs%t = rhs%t
  end subroutine
end module

subroutine ddsnnn005(lhs,rhs)
  use d
  type(mytype2) :: rhs
  type(mytype2) :: lhs
  lhs = rhs
end subroutine

• main.f90

use d
implicit none

integer, parameter :: count = 10000
integer :: i,j,k
type(mytype2) :: t1,t2
real :: start_t, end_t
interface
  subroutine ddsnnn005(lhs,rhs)
    use d
    type(mytype2) :: rhs
    type(mytype2) :: lhs
  end subroutine
end interface

call cpu_time(start_t)
do i=1,count
  do j=1,count
    call ddsnnn005(t1,t2)
  end do
end do
call cpu_time(end_t)

print *, end_t - start_t
end

• commands

$ flang -Ofast -mcpu=native test.f90 main.f90 && ./a.out # for A64FX/Grace
$ flang -Ofast -march=native test.f90 main.f90 && ./a.out # for Xeon

	Flang [s]	GFortran [s]
A64FX	26.61019	0.325082988
Grace	4.2784247	0.0608319975
Xeon	5.6451816	0.107244000

[klausler]

Has this bug been resolved in the current sources?

[yus3710-fj]

Flang has become 2x faster, but it's still 70x slower than GFortran. (As of d265105)
I've updated the data in the description.

[yus3710-fj]

For the above program, DerivedType::noDefinedAssignment_ might help avoid creating temporary. However, improving the runtime would be a more universal approach.

[klausler]

flang-new -fc1 -fdebug-unparse test.f90 shows that the defined assignment has been used to replace the assignment statement.

MODULE d
 TYPE :: mytype1
  INTEGER :: x, y, z
 END TYPE
 TYPE :: mytype2
  INTEGER :: x, y
  TYPE(mytype1) :: t
 END TYPE
 INTERFACE ASSIGNMENT(=)
  MODULE PROCEDURE :: swap
 END INTERFACE
CONTAINS
 PURE SUBROUTINE swap (lhs, rhs)
  TYPE(mytype2), INTENT(IN) :: rhs
  TYPE(mytype2), INTENT(OUT) :: lhs
   lhs%x=rhs%y
   lhs%y=rhs%x
   lhs%t=rhs%t
 END SUBROUTINE
END MODULE
SUBROUTINE ddsnnn005 (lhs, rhs)
 USE :: d
 TYPE(mytype2) :: rhs
 TYPE(mytype2) :: lhs
  CALL swap(lhs,(rhs))
END SUBROUTINE

The inefficiency likely arises from the parentheses around (rhs), which force the use of a temporary. A basic alias analysis in semantics would reveal that they aren't needed in this case.

[yus3710-fj]

Issue closed.
The issue seems to occur in several SPEC2017 benchmarks (wrf and cam4). However, it does not have a significant impact on overall performance.