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

278 lines
6.4 KiB
Markdown
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
如果升级到 **Fortran 2018**,方案会干净很多:可以把老的 Fortran95 计算核心保留,但用 Fortran 2018 的 `iso_c_binding`、`iso_fortran_env`、`event_type`/coarray 等现代能力做一层更稳的接口。不过要注意:**Fortran 2018 本身仍然没有标准的“操作系统共享内存 API”**,所以共享内存创建、映射、命名信号量这类事,仍建议由 C/C++ 或系统库封装。
我会推荐这个架构:
```text
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
```
核心原则不变:
```text
大数据:共享内存
小命令:控制通道
同步权:Controller
A/B:只按命令读写,不直接调度对方
```
**推荐模块划分**
```text
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 读写共享内存
```
**共享内存布局**
建议固定二进制布局,避免复杂对象:
```text
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 映射成数组:
```fortran
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 数组:
```fortran
call compute(field)
```
**双向数据区**
为了减少锁竞争,建议不要共用一块 buffer,而是两个单向通道:
```text
A_to_B_shm:
A 只写
B 只读
B_to_A_shm:
B 只写
A 只读
```
如果是实时流数据,再加双缓冲或三缓冲:
```text
A_to_B:
buffer[0]
buffer[1]
buffer[2]
```
Header 里放:
```text
write_index
read_index
latest_step
buffer_state[3]
```
**同步流程示例**
```text
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 可以并行计算,则改成:
```text
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 集成会更麻烦。
所以优先级我会排成:
```text
首选:Fortran 2018 + C IPC 封装 + 共享内存 + Controller
备选:MPI + Fortran 2018,如果你们本来就是 HPC/MPI 体系
谨慎:Fortran coarray,用于同一 Fortran 运行时生态内的并行程序
```
**最小接口设计**
C 层暴露给 Fortran 的接口可以保持很少:
```c
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 包一层:
```fortran
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 主循环大概是:
```fortran
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 后,最合适的方案是:
```text
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 代码只面对“数组 + 命令 + 状态”。