Files
CCLite/data_femlite_sphlite.md
2026-07-04 21:52:49 +08:00

6.4 KiB
Raw Permalink Blame History

如果升级到 Fortran 2018,方案会干净很多:可以把老的 Fortran95 计算核心保留,但用 Fortran 2018 的 iso_c_binding、iso_fortran_env、event_type/coarray 等现代能力做一层更稳的接口。不过要注意:Fortran 2018 本身仍然没有标准的“操作系统共享内存 API”,所以共享内存创建、映射、命名信号量这类事,仍建议由 C/C++ 或系统库封装。

我会推荐这个架构:

                 Controller
        进程启动 / 同步调度 / 状态机 / 异常恢复
                    |
        control IPC: pipe/socket/semaphore/event
          /                                \
         /                                  \
  Solver A                              Solver B
 Fortran 2018                         Fortran 2018
 计算 + IPC接口层                      计算 + IPC接口层

        shared memory A_to_B
        shared memory B_to_A

核心原则不变:

大数据:共享内存
小命令:控制通道
同步权:Controller
A/B:只按命令读写,不直接调度对方

推荐模块划分

controller
  - 创建共享内存
  - 创建同步对象
  - 启动 A/B
  - 发送 step/read/write/stop 命令
  - 等待 A/B done
  - 处理超时、崩溃、重启

ipc_c_layer
  - shm_create / shm_open / shm_map
  - event_wait / event_signal
  - mutex_lock / mutex_unlock
  - pipe_send / pipe_recv

fortran_ipc_module
  - Fortran 2018 包装层
  - 使用 iso_c_binding 调 C 接口
  - 把 C 指针转换成 Fortran 数组指针

solver_a / solver_b
  - 原计算逻辑
  - 调用 fortran_ipc_module 读写共享内存

共享内存布局

建议固定二进制布局,避免复杂对象:

SharedBlock
  Header
    magic
    version
    role
    step_id
    nx, ny, nz
    elem_kind
    data_bytes
    state
    error_code
  Payload
    real(real64) data(nx, ny, nz)

Fortran 2018 侧可以通过 c_f_pointer 把共享内存 payload 映射成数组:

use iso_c_binding
use iso_fortran_env, only: real64

type(c_ptr) :: raw_ptr
real(real64), pointer :: field(:,:,:)

raw_ptr = ipc_get_payload_ptr(handle)
call c_f_pointer(raw_ptr, field, [nx, ny, nz])

这样 Solver 看到的就是普通 Fortran 数组:

call compute(field)

双向数据区

为了减少锁竞争,建议不要共用一块 buffer,而是两个单向通道:

A_to_B_shm:
  A 只写
  B 只读

B_to_A_shm:
  B 只写
  A 只读

如果是实时流数据,再加双缓冲或三缓冲:

A_to_B:
  buffer[0]
  buffer[1]
  buffer[2]

Header 里放:

write_index
read_index
latest_step
buffer_state[3]

同步流程示例

Controller:
  create shared memory
  start A
  start B

loop step = 1..N:
  signal A: compute_and_write_A_to_B(step)
  wait A_done

  signal B: read_A_to_B_and_compute(step)
  wait B_done

  signal B: write_B_to_A(step)
  wait B_done

  signal A: read_B_to_A_and_update(step)
  wait A_done

shutdown:
  signal A/B stop
  release resources

如果 A/B 可以并行计算,则改成:

Controller:
  signal A and B start_step
  wait both done
  signal both exchange_ready
  wait both consumed

Fortran 2018 带来的好处

相比 Fortran95,主要提升在接口层:

能力 Fortran95 Fortran2018
调 C 接口 依赖编译器扩展 标准 iso_c_binding
整数/浮点 kind 不完全统一 iso_fortran_env 更清楚
C 指针转数组 麻烦且不标准 c_f_pointer 标准支持
字符串/枚举/句柄 易混乱 可用 c_ptr, c_int, c_size_t
并行同步 依赖外部库 可考虑 coarray/event,但跨进程仍有限

是否使用 coarray?

可以考虑,但我不建议作为第一方案。

Fortran 2018 的 coarray/event 适合 Fortran 程序之间的并行模型,但你的场景是:

  • 两个独立主控程序
  • 由第三个主控程序统一调度
  • 大数据同机交换
  • 需要工程上可控的进程生命周期

这种情况下,coarray 运行时可能反而把进程模型绑定到特定编译器和运行时,例如 Intel、GNU/OpenCoarrays、Cray 等。可移植性、调试和与外部 Controller 集成会更麻烦。

所以优先级我会排成:

首选:Fortran 2018 + C IPC 封装 + 共享内存 + Controller
备选:MPI + Fortran 2018,如果你们本来就是 HPC/MPI 体系
谨慎:Fortran coarray,用于同一 Fortran 运行时生态内的并行程序

最小接口设计

C 层暴露给 Fortran 的接口可以保持很少:

void* ipc_attach(const char* name, int role);
void* ipc_payload_ptr(void* handle, int buffer_id);
int   ipc_wait_command(void* handle, int* command, int* step_id);
int   ipc_signal_done(void* handle, int step_id, int status);
int   ipc_detach(void* handle);

Fortran 2018 包一层:

module ipc_mod
  use iso_c_binding
  implicit none

  type :: ipc_handle
    type(c_ptr) :: p = c_null_ptr
  end type

contains

  subroutine attach(handle, name, role)
  end subroutine

  subroutine map_real64_3d(handle, buffer_id, nx, ny, nz, field)
    type(ipc_handle), intent(in) :: handle
    integer, intent(in) :: buffer_id, nx, ny, nz
    real(c_double), pointer, intent(out) :: field(:,:,:)
  end subroutine

  subroutine wait_command(handle, command, step_id)
  end subroutine

  subroutine signal_done(handle, step_id, status)
  end subroutine

end module

Solver 主循环大概是:

do
  call wait_command(ipc, cmd, step_id)

  select case (cmd)
  case (CMD_COMPUTE_WRITE)
    call compute(local_state, out_field)
    call signal_done(ipc, step_id, STATUS_OK)

  case (CMD_READ_UPDATE)
    call update_from_peer(in_field)
    call signal_done(ipc, step_id, STATUS_OK)

  case (CMD_STOP)
    exit
  end select
end do

最终推荐

升级到 Fortran 2018 后,最合适的方案是:

Controller:
  独立主控程序,管理 A/B 生命周期和同步状态机

Solver A / Solver B:
  Fortran 2018 独立程序
  保留各自计算主循环
  通过统一 ipc_mod 接收命令、读写共享内存、上报状态

IPC 底层:
  C/C++ 封装 OS 共享内存 + semaphore/event/named pipe
  Fortran 2018 用 iso_c_binding 标准调用

这比 Fortran95 的版本更可维护、可移植、可测试。关键是把系统相关的复杂度压进很薄的 C/C++ IPC 层,让 Fortran 代码只面对“数组 + 命令 + 状态”。