问题[fortran](coding)

我想知道“％”如何在派生类型的数组上起作用。

我编写了以下程序，其中“+”运算符已被重载：

module my_mod

  implicit none

  type :: my_type
    real :: r1 , r2
    integer :: i1, i2
  end type my_type
  
  interface operator(+)
    module procedure add_my_type_vec, add_my_type
  end interface
  
contains
  function add_my_type_vec(a,b) result(res)
    type(my_type), dimension(:),intent(in) :: a, b
    type(my_type), dimension(size(a)) :: res

      res%r1 = a%r1 + b%r1
      res%r2 = a%r2 + b%r2
      res%i1 = a%i1 + b%i1
      res%i2 = a%i2 + b%i2
      
  end function add_my_type_vec
  
  function add_my_type(a,b) result(res)
    type(my_type), intent(in) :: a, b
    type(my_type) :: res

      res%r1 = a%r1 + b%r1
      res%r2 = a%r2 + b%r2
      res%i1 = a%i1 + b%i1
      res%i2 = a%i2 + b%i2
      
  end function add_my_type
  
end module my_mod

program my_pgm
    use my_mod
    implicit none
    
    type(my_type),allocatable, dimension(:) :: my_vec1, my_vec2, my_vec3
    
    write(*,*) "Sum on type : ", my_type(1.0, 2.0, 1, 2) + my_type(1.0, 2.0, 1, 2)

    allocate(my_vec1(1000), my_vec2(1000), my_vec3(1000))
    my_vec1 = my_type(1.0, 2.0, 1, 2)
    my_vec2 = my_type(1.0, 2.0, 1, 2)
    my_vec3 = my_vec1 + my_vec2
    
    write(*,*) "Sum on vec of type : ", my_vec3(123)
    

end program my_pgm

在函数中add_my_type_vec，它是如何%工作的？例如，在指令中res%r1 = a%r1 + b%r1，是否创建（即内存复制）两个仅包含a%r1和 的实数数组b%r1，然后对这些数组进行求和，最后对 进行赋值res%r1？我想这应该更复杂一些。

我正在尝试将并行化实现到我的博士学位论文的 flowsolver 代码中，我继承了一个在预定义子域之间发送数据的子程序。该子程序通过 MPI_Isend 命令发送数据，并使用 MPI_Irecv 命令接收数据，然后调用 waitall。

（有问题的代码如下：）

        ! -----------------------------------------------------------
        ! Definition of instant send/receive passings with barrier at the end
        ! -----------------------------------------------------------

        spos=1                          ! Position of the first element to send within send array
        do i=1,isize                    ! loop over the number of exchanging segments
            if (nsendseg(i).ne.0) then  ! choose only domains with something to send
                call MPI_ISend(send(spos),nsendseg(i),MPI_REAL8,i-1,1,MPI_COMM_WORLD,reqs(i),ierr)
                spos=spos+nsendseg(i)
            end if
        enddo
    
        rpos=1
        do i=1,isize
            if (nrecvseg(i).ne.0) then
                call MPI_IRecv(recv(rpos),nrecvseg(i),MPI_REAL8,i-1,MPI_ANY_TAG,MPI_COMM_WORLD,reqs(i+sum(nsendseg)),ierr)
                rpos=rpos+nrecvseg(i)
            end if
        end do
        
        if (irank .eq. 0) print *, reqs
        
        call MPI_Waitall(sum(nsendseg)+sum(nrecvseg),reqs,MPI_STATUSES_IGNORE,ierr)

编辑澄清 sum(nsendseg)+sum(nrecvseg)：我“相信”（我从一位前博士生那里继承了这段代码，而他自己又从另一位博士生那里继承了这段代码，所以有一些中国传言）nsendseg 代表段（核心）要发送的节点数和发送位置。例如，在 10 个核心上运行时，它们是 10 个整数的数组，表示跨核心的子域之间的共享节点，例如，如果段 3 与段 1 共享 12 个节点，与段 7 共享 3 个节点，而与其他任何段共享 0 个节点，则 nsendseg 为 (12,0,0,0,0,0,3,0,0,0)。任何段接收和发送的节点数都不同，因为许多段可以连接到一个段。这里的想法是每个核心都会遍历所有其他核心的列表，并仅从每个核心发送和接收相关数据。

此代码片段中止，并在部分或全部节点上复制下面的错误。

Abort(336210451) on node 13 (rank 13 in comm 0): Fatal error in PMPI_Waitall: Request pending due to failure, error stack:
PMPI_Waitall(352): MPI_Waitall(count=28734, req_array=0x18ac060, status_array=0x1) failed
PMPI_Waitall(328): The supplied request in array element 2 was invalid (kind=0)

我目前认为这里的错误在于 reqs 数组没有正确传递给它的通信句柄。下面的文本块是 reqs 数组的一个示例，它“感觉”像是 isend 或 irecv 子程序试图放入一个奇怪的数据类型（reqs 是一个默认整数数组）。

           0 -1409286132           0           0 -1409286133 -1409286135
 -1409286134           0           0           0           0           0
           0           0           0           0           0           0
           0           0           0           0           0           0
           0           0           0           0           0           0
           0           0           0           0           0           0
           0           0           0           0           0           0
           0           0           0           0           0           0
           0           0           0           0           0           0
           0           0           0           0           0           0
           0           0           0           0           0 -1409286131
           0           0 -1409286130 -1409286129 -1409286128           0
           0           0           0           0           0           0
           0           0           0           0           0           0
           0           0           0           0           0           0
           0           0           0           0           0           0
           0           0           0           0           0           0
           0           0           0           0           0           0
           0           0           0           0           0           0
           0           0           0           0           0           0
           0           0           0           0           0           0
           0           0

我知道这有点像是在瞎猜，因为我基本上是在要求随机的互联网用户猜测一段早已离开的人写的代码的含义。

有人能看到我的错误根源吗，或者告诉我 mpi 通信句柄应该是什么样子，或者任何其他明智的建议，我将不胜感激。<3

我在 Fortran 中定义派生类型并重载一些运算符（例如 + 运算符）。这在处理标量对象时效果很好，我（乐观地）希望这可以无缝地处理这些对象的数组，但事实并非如此。

在下面的例子中，我为 2D 平面中的点定义了一个派生类型，并且重载了 + 运算符来定义两个点的和应该是多少（此操作不需要在数学上有意义——这只是一个简单的例子……）。这适用于单个点，但不适用于点数组。

编译时的错误信息为：

• gcc：二进制内在数字运算符‘+’中出现意外的派生类型实体

• ifort：此二元运算对于此数据类型无效。

让它与点数组一起工作的最好/最简单的方法是什么？

module points

  implicit none

  type :: t_point
    integer :: x, y
  contains
    procedure :: add
    generic :: operator(+) => add
  end type t_point

contains

  pure type(t_point) function add(self, other)
    class(t_point), intent(in) :: self, other
    add = t_point(self%x + other%x, self%y + other%y)
  end function add

end module points

program test

  use points

  implicit none

  type(t_point) :: p1, p2, p3

  p1 = t_point(0, 1)
  p2 = t_point(1, 4)
  p3 = t_point(5, -1)

  print*, p1 + p1 ! this works: (0, 2)                                                                                                                             
  print*, p1 + p2 ! this works: (1, 5)                                                                                                                             
  print*, p1 + p3 ! this works: (5, 0)                                                                                                                             
  print*, p2 + p3 ! this works: (6, 3)                                                                                                                             

  print*, (/1, 2, 3/) + (/10, 20, 30/) ! this works with intrinsic data types: (11, 22, 33)                                                                        

  print*, (/p1, p2, p3/) + (/p3, p3, p3/) ! compilers do not like this line                                                                                        

end program test

问题正是标题：Fortran 允许在SUBROUTINE即使有的情况下更改派生类型数据成员INTENT(IN)，如何保护数据？我对 Fortran 还很陌生，尽管INTENT(IN)派生类型伪参数具有属性，但这种允许改变派生类型数据成员的行为让我非常担心。有没有办法用编译器捕获这些不安全的突变？例如，gfortran -Wall似乎没有这样做，但也许这是遗留甚至现代代码库中一个相当常见的问题，以至于可以通过某种方式对问题进行某种静态检测？

示例程序：

! @file main.f90
!
! @purpose: Show data members of derived types are mutable in SUBROUTINE 
!
! @compile: gfortran -Wall main.f90
PROGRAM test
    IMPLICIT NONE

    INTEGER :: n_states = 1
    INTEGER :: len_state = 5 
    INTEGER :: i, j

    TYPE t_states 
        INTEGER, POINTER, CONTIGUOUS :: state(:) ! (len_state,)
    END TYPE t_states

    TYPE(t_states), ALLOCATABLE :: states(:) ! (n_states,)

    ALLOCATE(states(1:n_states)) 

    ! Populate allocated array of states
    DO i = 1, n_states 
        ALLOCATE(states(i)%state(len_state))
        DO j = 1, len_state 
            states(i)%state(j) = j
            PRINT *, states(i)%state(j)
        END DO
        PRINT *
    END DO
 
    CALL unsafe_mutation(states(1))

    ! Print state array after modification
    DO j = 1, len_state
        PRINT *, states(1)%state(j)
    END DO 

CONTAINS

    ! Arbitrary update of state data member even though INTENT(IN)!!!
    SUBROUTINE unsafe_mutation(p_states)
        TYPE(t_states), INTENT(in) :: p_states
        p_states%state(1) = -1 
    END SUBROUTINE

END PROGRAM test

输出：

           1
           2
           3
           4
           5

          -1
           2
           3
           4
           5

我想将指向函数的指针存储为具有类型的属性。但编译器抱怨函数的第一个参数应该是类型（如Python 或 C++ 等语言中的self或this参数）。但属性只是一个指针 - 它不是类型的一部分。

以下是一些代码：

module my_mod

  implicit none
  public :: my_type

  abstract interface
    ! INTERFACE I WANT TO POINT TO
    subroutine my_interface(arg)
      real, intent(in) :: arg
    end subroutine my_interface
  end interface

  type :: my_type
    ! MY TYPE DEFINITION
    real :: my_variable
    procedure(my_interface), pointer :: my_fn_pointer
  end type my_type

  interface my_type
    ! "CONSTRUCTOR" INTERFACE FOR MY TYPE
    module procedure init_my_type
  end interface

  contains

  type(my_type) function init_my_type(arg1, arg2)
    ! ACTUAL "CONSTRUCTOR" FOR MY TYPE
    real, intent(in) :: arg1
    procedure(my_interface) :: arg2

    init_my_type%my_variable = arg1
    init_my_type%my_fn_pointer => arg2
  end function init_my_type

end module my_mod

我得到的实际错误（ifort 编译器）是：

错误 #8262：对于具有 PASS 绑定属性的类型绑定过程，第一个虚拟参数必须具有与所定义类型相同的声明类型。

我不明白为什么它认为我想要指向的接口是一个类型绑定的过程。

有什么提示吗？

我有一个主程序和一个模块。我希望主程序在正常情况下使用模块的某些部分，但如果使用“DEBUG”cpp 宏编译，则使用一些添加的元素。这是我发现的使这项工作有效的方法：

    program myprogram
    
    use comp_module, only: data1, routine1 &
    #idef DEBUG
                           , debug_data, debug routine
    #endif
    ;
    ....

如果我不在末尾添加分号，编译器会在未编译进行调试时认为这是一个错误。所以，这有效。

只是它看起来有点不优雅，调试行中有一个前导逗号，后面有一个无用的分号。我可以看到一些开发人员稍后出现，不明白发生了什么，并重新引入编译器错误。

有什么更好的办法呢？