Performance 在fortran中使用模块的性能测试

我正在将一个F77代码转换成F90，我正在尝试摆脱隐式声明和包含

特别是，我有一个子程序（经常调用）

子程序：

  SUBROUTINE GRADE(NIE,NJE,NKE,IDEW,IDNS,IDTB,FI,FIF,GRX,GRY,GRZ)
  USE module_dec
  USE module_geom_common
  IMPLICIT NONE
  REAL    :: FI(NXYZA),FIF(NXYZA)
  REAL    :: GRX(NXYZA),GRY(NXYZA),GRZ(NXYZA)
  REAL    :: BN(NXYZA),BE(NXYZA),BT(NXYZA)
  REAL    :: FIE
  INTEGER :: NIE,NJE,NKE,IDEW,IDNS,IDTB
  INTEGER :: I,J,K

  ! Declaration of the variables used in file.inc
  REAL    :: ARX,ARY,ARZ
  REAL    :: AKX,AKY,AKZ
  REAL    :: ARE,ARE2,ARKSI2
  REAL    :: FXE,FXW
  INTEGER :: INE
  REAL    :: DELN,DELNR

  DO 30 K=2,NKE
  DO 30 I=2,NIE
  DO 30 J=2,NJE

  INCLUDE "file.inc"

    FIE=FI(INP)*FXW+FI(INE)*FXE
    BE(INP)=  FIE*ARX
    BN(INP)=  FIE*ARY
    BT(INP)=  FIE*ARZ

  30 CONTINUE

  DO 31 K=2,NKE
  DO 31 I=2,NIE
  DO 31 J=2,NJE

    INP=LK(K)+LI(I)+J
    GRX(INP)=GRX(INP)+BE(INP)
    GRY(INP)=GRY(INP)+BN(INP)
    GRZ(INP)=GRZ(INP)+BT(INP)

    GRX(INP+IDEW)=GRX(INP+IDEW)-BE(INP)
    GRY(INP+IDEW)=GRY(INP+IDEW)-BN(INP)
    GRZ(INP+IDEW)=GRZ(INP+IDEW)-BT(INP)

  31 CONTINUE

和文件公司

  INP=LK(K)+LI(I)+J
  INE=INP+IDEW
  INS=INP-IDNS
  INB=INP-IDTB
  INBS=INB-IDNS

  FXE=FIF(INP)
  FXW=1.-FXE

  DXS=.5*(X(INP)-X(INS)+X(INB)-X(INBS))
  DYS=.5*(Y(INP)-Y(INS)+Y(INB)-Y(INBS))
  DZS=.5*(Z(INP)-Z(INS)+Z(INB)-Z(INBS))

  DXT=.5*(X(INP)-X(INB)+X(INS)-X(INBS))
  DYT=.5*(Y(INP)-Y(INB)+Y(INS)-Y(INBS))
  DZT=.5*(Z(INP)-Z(INB)+Z(INS)-Z(INBS))

  ARX=DYS*DZT-DYT*DZS
  ARY=DZS*DXT-DZT*DXS
  ARZ=DXS*DYT-DXT*DYS

  ARE2=ARX**2+ARY**2+ARZ**2

  AKX=XC(INE)-XC(INP)
  AKY=YC(INE)-YC(INP)
  AKZ=ZC(INE)-ZC(INP)
  ARKSI2=AKX**2+AKY**2+AKZ**2

使用wich，我的程序的执行时间为12秒

当我移动模块中“file.inc”中存在的变量声明时

  MODULE module_geom_common
    REAL    :: ARX,ARY,ARZ
    REAL    :: AKX,AKY,AKZ
    REAL    :: ARE,ARE2,ARKSI2
    REAL    :: FXE,FXW
    INTEGER :: INE
    REAL    :: DELN,DELNR
  END MODULE module_geom_common

我现在的执行时间是13秒

我用ifort编译，但我用gfortran观察到同样的行为

我不明白为什么我跑得慢。 是不是因为模块中声明的变量将被放在内存中，导致缓存丢失或类似的情况

有没有一种不使用include的方法来克服这个问题

---

编辑：我编辑了我的问题以提供更多细节。

局部变量可以在堆栈上甚至寄存器上分配，而模块变量是静态分配的。如果您的代码进行任何过程调用，编译器必须假设模块变量可以访问或修改，而参数列表中不包含的局部变量则不能访问或修改，这可能会影响优化。如果看不到完整的例子，很难进一步推测。你是如何安排时间的？