From a2126f360cb2b64937447075d025de86e17a6fa1 Mon Sep 17 00:00:00 2001 From: shenw Date: Sun, 5 Jul 2026 21:09:37 +0800 Subject: [PATCH] Release 0.6.5 real IPC worker --- CMakeLists.txt | 121 ++- README.md | 8 +- docs/01_requirements_specification.md | 23 +- docs/02_software_architecture_design.md | 2 +- docs/03_detailed_design.md | 2 +- docs/04_mathematical_model_and_algorithms.md | 2 +- docs/05_interface_control_document.md | 24 +- docs/06_test_and_verification_plan.md | 21 +- docs/07_user_manual.md | 25 +- docs/08_developer_manual.md | 6 +- docs/09_release_history.md | 41 +- docs/10_development_roadmap.md | 30 +- docs/11_benchmark_matrix.md | 12 +- docs/12_cclite_integration_suggestions.md | 478 +++++----- docs/README.md | 4 +- include/femlite_cclite_ipc.h | 67 ++ src/app/fem_program.f90 | 131 ++- src/interface/fem_cclite_ipc.c | 64 +- src/worker/fem_cclite_worker.f90 | 874 +++++++++++++++++-- tests/cmake/run_cclite_capabilities.cmake | 28 + tests/interface/test_cclite_ipc_adapter.c | 22 + tests/interface/test_cclite_worker_process.c | 338 +++++++ todo.md | 126 +-- 23 files changed, 2007 insertions(+), 442 deletions(-) create mode 100644 tests/cmake/run_cclite_capabilities.cmake create mode 100644 tests/interface/test_cclite_worker_process.c diff --git a/CMakeLists.txt b/CMakeLists.txt index ce96b9d..784539a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,7 +1,7 @@ cmake_minimum_required(VERSION 3.20) project(FemLite - VERSION 0.6.4 + VERSION 0.6.5 LANGUAGES C Fortran ) @@ -61,6 +61,37 @@ function(femlite_apply_fortran_options target_name) endif() endfunction() +function(femlite_apply_fortran2018_options target_name) + set_target_properties(${target_name} PROPERTIES + Fortran_STANDARD 2018 + Fortran_STANDARD_REQUIRED ON + ) + if(CMAKE_Fortran_COMPILER_ID MATCHES "GNU") + target_compile_options(${target_name} PRIVATE + -std=f2018 + -fall-intrinsics + -Wall + -Wextra + -Wimplicit-interface + $<$:-g> + $<$:-O0> + $<$:-fcheck=all> + $<$:-fbacktrace> + ) + elseif(CMAKE_Fortran_COMPILER_ID MATCHES "Intel") + if(WIN32) + target_compile_options(${target_name} PRIVATE + $<$:/Od> + ) + else() + target_compile_options(${target_name} PRIVATE + $<$:-g> + $<$:-O0> + ) + endif() + endif() +endfunction() + add_library(femlite_core STATIC src/base/fem_precision.f90 src/base/fem_error.f90 @@ -180,7 +211,6 @@ add_library(femlite_core STATIC src/base/fem_api_state_access.f90 src/base/fem_api_stable_dt.f90 src/base/fem_api.f90 - src/worker/fem_cclite_worker.f90 src/interface/fem_fortran_bridge.f90 ) @@ -203,12 +233,29 @@ if(FEMLITE_ENABLE_OPENMP) endif() endif() -add_library(femlite_c STATIC - src/interface/fem_c_api.c +add_library(femlite_ipc_c STATIC src/interface/fem_cclite_ipc.c ) -target_link_libraries(femlite_c PUBLIC femlite_core) +target_include_directories(femlite_ipc_c PUBLIC + "$" +) + +add_library(femlite_worker STATIC + src/worker/fem_cclite_worker.f90 +) + +target_link_libraries(femlite_worker PUBLIC femlite_core femlite_ipc_c) +target_include_directories(femlite_worker PUBLIC + "$" +) +femlite_apply_fortran2018_options(femlite_worker) + +add_library(femlite_c STATIC + src/interface/fem_c_api.c +) + +target_link_libraries(femlite_c PUBLIC femlite_core femlite_ipc_c) target_include_directories(femlite_c PUBLIC "$" "$" @@ -219,7 +266,8 @@ add_executable(femlite ) target_link_libraries(femlite PRIVATE femlite_core) -femlite_apply_fortran_options(femlite) +target_link_libraries(femlite PRIVATE femlite_worker) +femlite_apply_fortran2018_options(femlite) add_executable(test_smoke tests/unit/test_smoke.f90 @@ -623,6 +671,12 @@ add_executable(test_cclite_ipc_worker_loop target_link_libraries(test_cclite_ipc_worker_loop PRIVATE femlite_c) +add_executable(test_cclite_worker_process + tests/interface/test_cclite_worker_process.c +) + +target_link_libraries(test_cclite_worker_process PRIVATE femlite_ipc_c) + add_executable(test_implicit_inp tests/module/test_implicit_inp.f90 ) @@ -968,6 +1022,61 @@ set_tests_properties(cclite_ipc_worker_loop PROPERTIES WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}" ) +add_test(NAME cclite_capabilities + COMMAND "${CMAKE_COMMAND}" + -DFEMLITE_EXE=$ + -P ${CMAKE_SOURCE_DIR}/tests/cmake/run_cclite_capabilities.cmake +) +set_tests_properties(cclite_capabilities PROPERTIES + WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}" +) + +add_test(NAME cclite_worker_process_1step + COMMAND test_cclite_worker_process + $ + ${CMAKE_SOURCE_DIR} + 1 +) +set_tests_properties(cclite_worker_process_1step PROPERTIES + WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}" + TIMEOUT 30 +) + +add_test(NAME cclite_worker_process_100step + COMMAND test_cclite_worker_process + $ + ${CMAKE_SOURCE_DIR} + 100 +) +set_tests_properties(cclite_worker_process_100step PROPERTIES + WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}" + TIMEOUT 60 +) + +add_test(NAME cclite_worker_process_timeout + COMMAND test_cclite_worker_process + $ + ${CMAKE_SOURCE_DIR} + 0 + timeout +) +set_tests_properties(cclite_worker_process_timeout PROPERTIES + WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}" + TIMEOUT 30 +) + +add_test(NAME cclite_worker_process_badcase + COMMAND test_cclite_worker_process + $ + ${CMAKE_SOURCE_DIR} + 0 + badcase +) +set_tests_properties(cclite_worker_process_badcase PROPERTIES + WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}" + TIMEOUT 30 +) + add_test(NAME perf_contact_pair_smoke COMMAND perf_contact_pair 32 1) set_tests_properties(perf_contact_pair_smoke PROPERTIES WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}" diff --git a/README.md b/README.md index 7cde197..b7eff3d 100644 --- a/README.md +++ b/README.md @@ -2,9 +2,9 @@ FemLite 是一个轻量级有限元求解器,核心使用 Fortran 实现,面向结构动力学、静力学、非线性分析、壳/实体单元、接触、材料非线性和紧凑工程 benchmark 开发。 -当前项目版本:**0.6.4**。 +当前项目版本:**0.6.5**。 -0.6.4 是 CCLite coupling 基础闭环版本,新增中立 coupling API、worker mock、Windows IPC adapter、surface/facet 扩展导出、外部节点力导入和诊断报告。`v0.5.0` 仍是第五版验收检查点,0.6.x 在此基础上继续维护元素基础设施、生命周期诊断、restart 诊断、contact/solver/path 输出硬化和 release gate。 +0.6.5 是 CCLite 真实 IPC worker 接入闭环版本,在 0.6.4 的中立 coupling API、worker mock、Windows IPC adapter、surface/facet 扩展导出、外部节点力导入和诊断报告基础上,新增标准 worker 参数、AOR_V1 data block、能力查询和进程级 IPC 自测。`v0.5.0` 仍是第五版验收检查点,0.6.x 在此基础上继续维护元素基础设施、生命周期诊断、restart 诊断、contact/solver/path 输出硬化和 release gate。 ## 当前能力 @@ -17,7 +17,7 @@ FemLite 是一个轻量级有限元求解器,核心使用 Fortran 实现,面 - 接触、mortar/AL、摩擦、cohesive 和颗粒耦合诊断基础设施。 - CSV、VTU/PVD、restart、Fortran API 和 C ABI。 - 元素元数据、节点、坐标、积分点、形函数、Jacobian 和 B 矩阵查询。 -- CCLite coupling surface/facet 查询、节点力导入、worker mock、IPC adapter 和载荷诊断 CSV。 +- CCLite coupling surface/facet 查询、节点力导入、worker mock、真实 IPC worker、IPC adapter 和载荷诊断 CSV。 ## 当前不声明的能力 @@ -47,7 +47,7 @@ cmake --build build-codex-gcc --parallel ctest --test-dir build-codex-gcc --output-on-failure ``` -## 0.6.4 Release Gate +## 0.6.5 Release Gate ```powershell cmake --build build-codex-gcc --parallel diff --git a/docs/01_requirements_specification.md b/docs/01_requirements_specification.md index 05f074e..a1b678f 100644 --- a/docs/01_requirements_specification.md +++ b/docs/01_requirements_specification.md @@ -1,12 +1,12 @@ # 01 需求规格说明 -文档状态:0.6.4 版整理稿 +文档状态:0.6.5 版整理稿 ## 1. 软件定位 FemLite 是一个轻量级有限元求解器,核心使用 Fortran 实现,面向结构动力学、静力学、非线性分析、壳/实体单元、接触、材料非线性和紧凑工程基准算例开发。 -当前项目版本为 0.6.4。0.6.4 是 CCLite coupling 基础闭环版本,重点交付中立 coupling API、worker mock、Windows IPC adapter、surface/facet 扩展导出、外部节点力导入和诊断报告。 +当前项目版本为 0.6.5。0.6.5 是 CCLite 真实 IPC worker 接入闭环版本,重点交付标准 worker 参数、真实 Windows IPC worker 后端、AOR_V1 data block、能力查询和进程级 IPC 自测。 ## 2. 当前交付范围 @@ -21,7 +21,7 @@ FemLite 是一个轻量级有限元求解器,核心使用 Fortran 实现,面 - 基础接触、mortar/AL、摩擦、cohesive 和颗粒耦合诊断基础设施。 - CSV、VTU/PVD、restart、Fortran API 和 C ABI 输出/查询接口。 - 元素 introspection API:元素类型、节点、坐标、积分点、形函数、Jacobian 和 B 矩阵。 -- CCLite coupling surface/facet 查询、节点力导入、worker mock、IPC adapter 和载荷诊断 CSV。 +- CCLite coupling surface/facet 查询、节点力导入、worker mock、真实 IPC worker、IPC adapter 和载荷诊断 CSV。 - `continuation_path.csv`、`nonlinear_lifecycle.csv` 和 restart version 5 生命周期诊断。 ## 3. 0.6.4 新增需求 @@ -34,9 +34,20 @@ FemLite 是一个轻量级有限元求解器,核心使用 Fortran 实现,面 - 增加 worker mock 命令状态机和 VTU/PVD + coupling 诊断输出闭环。 - 增加 Windows shared memory / named event IPC adapter 的 C 层边界。 - 保留 0.6.3 的 `S4R`、受控 `C3D8R`、积分规则基础设施和元素 introspection API。 -## 4. 明确不交付范围 -以下内容不属于 0.6.4 交付: +## 4. 0.6.5 新增需求 + +0.6.5 的新增需求已经交付: + +- 增加 `--worker-backend ipc` 真实 Windows IPC worker 路径,支持 READY、INIT、STEP、STOP、ERROR 命令闭环。 +- 增加 `--solver-id`、`--timeout-ms`、`--worker-id`、`--command-block`、`--data-prefix` 等标准 worker 参数。 +- 增加 AOR_V1 data block 布局、初始化和校验接口,支持 surface/facet 导出和 nodal load 导入的共享内存数据段边界。 +- 增加 `--cclite-capabilities` 能力查询输出,便于 CCLite 侧进行启动前能力探测。 +- 增加真实进程级 IPC worker 小闭环、100 step、timeout 和异常输入自测。 + +## 5. 明确不交付范围 + +以下内容不属于 0.6.5 交付: - 完整 reduced-integration solid 家族。 - 完整 Abaqus 单元库。 @@ -50,7 +61,7 @@ FemLite 是一个轻量级有限元求解器,核心使用 Fortran 实现,面 - 真实 SPH-FEM penalty contact、FSI 和强耦合 rollback。 - 生产级滚压成形工艺链。 -## 5. 质量要求 +## 6. 质量要求 - 所有新增功能必须有小型、可重复的测试或 checker。 - 公开接口必须通过 `ierr` 或 C 返回码报告错误,不得直接终止程序。 diff --git a/docs/02_software_architecture_design.md b/docs/02_software_architecture_design.md index 90cd3cc..95839ed 100644 --- a/docs/02_software_architecture_design.md +++ b/docs/02_software_architecture_design.md @@ -1,6 +1,6 @@ # 02 软件架构设计 -文档状态:0.6.4 版整理稿 +文档状态:0.6.5 版整理稿 ## 1. 架构概览 diff --git a/docs/03_detailed_design.md b/docs/03_detailed_design.md index 09baa83..01ea5bd 100644 --- a/docs/03_detailed_design.md +++ b/docs/03_detailed_design.md @@ -1,6 +1,6 @@ # 03 详细设计 -文档状态:0.6.4 版整理稿 +文档状态:0.6.5 版整理稿 ## 1. 模型数据库 diff --git a/docs/04_mathematical_model_and_algorithms.md b/docs/04_mathematical_model_and_algorithms.md index 624bff0..f5a17e4 100644 --- a/docs/04_mathematical_model_and_algorithms.md +++ b/docs/04_mathematical_model_and_algorithms.md @@ -1,6 +1,6 @@ # 04 数学模型与算法 -文档状态:0.6.4 版整理稿 +文档状态:0.6.5 版整理稿 ## 1. 控制方程 diff --git a/docs/05_interface_control_document.md b/docs/05_interface_control_document.md index 1096527..1827301 100644 --- a/docs/05_interface_control_document.md +++ b/docs/05_interface_control_document.md @@ -1,6 +1,6 @@ # 05 接口控制文档 -文档状态:0.6.4 版整理稿 +文档状态:0.6.5 版整理稿 ## 1. Fortran API 总则 @@ -276,9 +276,9 @@ seq,ack_seq,command_id,step_id,substep_id,iteration_id,state,error_code - `ADVANCE` 使用单步显式推进。 - `WRITE_OUTPUT` 调用现有 CSV 与 VTU/PVD 输出路径。 -## 9. CCLite Windows IPC Adapter +## 9. CCLite Windows IPC Worker -阶段 C 提供 Windows IPC adapter 的 C 层边界,供后续真实 CCLite worker 接入。当前 adapter 已有 shared memory、named event、command block 读写和 smoke,不等同于主程序已经完成跨进程 worker 联调。 +阶段 C 提供 Windows IPC adapter 的 C 层边界。0.6.5 起主程序 worker 已接入真实 Windows IPC 后端,可由外部驱动创建 shared memory、named event 和 data block 后启动 `femlite --cclite-worker --worker-backend ipc`,完成 READY、INIT 到 STOP、空载荷推进和超时/异常退出闭环。 C 头文件: @@ -299,6 +299,7 @@ typedef struct femlite_cclite_command_block { int32_t iteration_id; int32_t worker_state; int32_t error_code; + char error_message[128]; } femlite_cclite_command_block; ``` @@ -316,9 +317,24 @@ adapter 约定: - FemLite 可以 wait `COMMAND_EVENT`、读取 command block、写回 `ack_seq`/`worker_state`/`error_code` 并 signal `DONE_EVENT`。 - FemLite 不 reset event;reset 责任属于 CCLite 侧。 - timeout 使用稳定错误码 `FEMLITE_CCL_IPC_ERR_TIMEOUT`。 -- 当前 smoke 覆盖 open、wait/signal、不 reset event、INIT/STOP、错误路径和 100 step 空耦合。 +- 当前 smoke 覆盖 open、wait/signal、不 reset event、INIT/STOP、错误路径、真实进程 1 step/100 step 空耦合和 timeout。 - `femlite_cclite_transport` 提供 mock 和 Windows IPC 两个 backend 的统一 `receive/complete` facade。 +data block 命名规则: + +```text +_FEM_TO_CCL_FACET +_CCL_TO_FEM_LOAD +``` + +data block 采用 `AOR_V1` 布局: + +- header 字段包含 `magic`、`version`、`layout`、`record_type`、`record_capacity`、`record_count`、`record_stride`、`status_code`、`error_code` 和短错误消息。 +- `FEM_TO_CCL_FACET` 记录包含 facet id、surface id、element/face id、节点列表、节点位置、节点速度、法向、面积、材料/截面 id、`body_id=0` 占位、valid flags、壳厚度和面密度。 +- `CCL_TO_FEM_LOAD` 记录包含 record id、step id、node id、source id、load mode、distribution mode、valid flags、节点力和预留力矩字段。 +- 容量不足、版本不匹配或 record stride 不匹配会返回错误,不静默截断。 +- 当前中立 data block 已支持 facet 导出和节点力导入;facet pressure、moment 和 kinematic boundary 仍是后续能力。 + ## 10. 输出接口 ```fortran diff --git a/docs/06_test_and_verification_plan.md b/docs/06_test_and_verification_plan.md index 04dc3dd..c365e09 100644 --- a/docs/06_test_and_verification_plan.md +++ b/docs/06_test_and_verification_plan.md @@ -1,6 +1,6 @@ # 06 测试与验证计划 -文档状态:0.6.4 版整理稿 +文档状态:0.6.5 版整理稿 ## 1. 测试分层 @@ -13,7 +13,7 @@ | benchmark | 带 checker 的紧凑工程验收 | | release gate | 当前版本发布前必须通过的组合测试 | -## 2. 当前 0.6.4 Release Gate +## 2. 当前 0.6.5 Release Gate ```powershell cmake --build build-codex-gcc --parallel @@ -21,13 +21,13 @@ ctest --test-dir build-codex-gcc --output-on-failure git diff --check ``` -当前本地 0.6.4 证据: +当前本地 0.6.5 证据: - 完整编译通过。 -- 完整回归 73/73 通过。 -- CCLite/coupling 相关回归覆盖 `c_api`、`facet_nodal_c_api`、`cclite_worker_mock`、`cclite_ipc_adapter`、`cclite_ipc_worker_loop`、`implicit_inp` 和 `vtk_output`。 +- 完整回归 78/78 通过。 +- CCLite/coupling 相关回归覆盖 `c_api`、`facet_nodal_c_api`、`cclite_worker_mock`、`cclite_ipc_adapter`、`cclite_ipc_worker_loop`、`cclite_capabilities`、`cclite_worker_process_1step`、`cclite_worker_process_100step`、`cclite_worker_process_timeout`、`cclite_worker_process_badcase`、`implicit_inp` 和 `vtk_output`。 - `git diff --check` 通过。 -## 3. 0.6.4 聚焦覆盖 +## 3. 0.6.5 聚焦覆盖 | 测试 | 覆盖内容 | |---|---| @@ -35,8 +35,13 @@ git diff --check | `implicit_inp` | coupling 节点力叠加到静力线性 RHS 后产生位移响应 | | `facet_nodal_c_api` | surface/facet 扩展字段、退化 facet、壳厚度和 surface 名称过滤 | | `cclite_worker_mock` | worker 命令状态机、seq/ack、100 step 空耦合、VTU/PVD 和 coupling 诊断报告 | -| `cclite_ipc_adapter` | shared memory、named event、timeout、wait/signal 和不 reset event | +| `cclite_ipc_adapter` | shared memory、named event、timeout、wait/signal、不 reset event 和 AOR_V1 data block 布局 | | `cclite_ipc_worker_loop` | transport facade 下 INIT 到 STOP 和 100 step 空耦合 | +| `cclite_capabilities` | `--cclite-capabilities` 稳定 key=value 输出 | +| `cclite_worker_process_1step` | 真实 `femlite.exe --worker-backend ipc` 进程级 1 step 空耦合 | +| `cclite_worker_process_100step` | 真实 IPC worker 进程级 100 step 空耦合、seq/ack 和 STOP | +| `cclite_worker_process_timeout` | 真实 IPC worker timeout 可控退出 | +| `cclite_worker_process_badcase` | 真实 IPC worker 异常输入可控退出 | | `vtk_output` | 默认 VTU/PVD 场变量输出路径 | ## 4. V5 验收子集 @@ -75,7 +80,7 @@ git diff --check ## 7. 非默认长跑 -以下属于后续或专项验证,不作为 0.6.4 默认 gate: +以下属于后续或专项验证,不作为 0.6.5 默认 gate: - 完整 `uz=-6.2 m` 球冠后屈曲 PDF 曲线匹配。 - Mohr-Coulomb 临界失稳云图长跑。 diff --git a/docs/07_user_manual.md b/docs/07_user_manual.md index ff41bb2..2cb5cb3 100644 --- a/docs/07_user_manual.md +++ b/docs/07_user_manual.md @@ -1,6 +1,6 @@ # 07 用户手册 -文档状态:0.6.4 版整理稿 +文档状态:0.6.5 版整理稿 ## 1. 构建 @@ -88,7 +88,7 @@ C 数组为 Fortran 顺序展开。例如 B 矩阵元素位置为: bmat[row + row_count * col] ``` -## 7. CCLite worker mock +## 7. CCLite worker FemLite 提供 CCLite worker mock 模式,用于验证命令状态机、空耦合推进和结果输出: @@ -99,6 +99,25 @@ femlite --cclite-worker --case input.inp --ipc-name mock ` 该模式会顺序执行 `INIT`、`READ_INPUT`、`BUILD_MODEL`、`EXPORT_INTERFACE`、`IMPORT_LOADS`、`ADVANCE`、`WRITE_OUTPUT` 和 `STOP`,并写出 worker 日志。它仍不是 Windows shared memory/named event IPC。 +真实 IPC worker 使用 CCLite 创建的 command block、data block 和 named event: + +```powershell +femlite --cclite-worker --worker-backend ipc --solver-id FEM ` + --case input.inp --ipc-name CCLITE_CASE001 ` + --data-prefix CCLITE_CASE001 --timeout-ms 30000 ` + --log femlite_cclite_worker.log +``` + +`--mock-steps` 存在时会强制进入 mock 模式;真实 IPC 模式应显式使用 `--worker-backend ipc`。FemLite 只 open/wait/signal CCLite 创建的 IPC 对象,不 reset event。当前真实 IPC worker 已支持 READY、INIT 到 STOP、`FEM_TO_CCL_FACET` 的 `AOR_V1` facet 导出、`CCL_TO_FEM_LOAD` 的 `AOR_V1` 节点力导入、1 step/100 step 空耦合 smoke、异常输入和 timeout 可控退出。 + +能力查询: + +```powershell +femlite --cclite-capabilities +``` + +输出是稳定 `key=value` 文本,包含 worker mock、Windows IPC、`AOR_V1` data block、facet 导出和节点力导入能力。 + `WRITE_OUTPUT` 会把 VTU/PVD 结果和 coupling 诊断表写到同一输出目录: - `results.pvd` 与 `result_XXXXXXXX.vtu` @@ -136,4 +155,4 @@ FemLite 支持 Abaqus INP 子集。非关键 keyword 可能 warning 后跳过; - 完整 cohesive 主线接触 step。 - DEM/FEM 子循环。 - 生产级滚压成形流程。 -- 真实 CCLite Windows IPC 联调。 +- 真实 SPH-FEM penalty contact、FSI 和强耦合 rollback。 diff --git a/docs/08_developer_manual.md b/docs/08_developer_manual.md index 8973464..b360435 100644 --- a/docs/08_developer_manual.md +++ b/docs/08_developer_manual.md @@ -1,6 +1,6 @@ # 08 开发者手册 -文档状态:0.6.4 版整理稿 +文档状态:0.6.5 版整理稿 ## 1. 基本原则 @@ -72,7 +72,7 @@ git diff --check 历史版本计划、验收报告和 benchmark 矩阵不再拆成多个文件;统一维护在 09-11。 -## 7. 0.6.4 开发注意事项 +## 7. 0.6.x 开发注意事项 - `S4R` hourglass 修改必须保持 `S4` 回归绿色。 - `C3D8R` hourglass 修改必须保持 `C3D8` 回归绿色,并覆盖刚度、内力、质量和输出路径。 @@ -81,4 +81,4 @@ git diff --check - 新增积分规则不等于开放用户侧积分选择。 - coupling external load 必须通过中立 API 导入和清理,不得让外部程序直接写 FemLite 全局力数组。 - worker/IPC 改动必须保持 FemLite 只 open CCLite 创建的 shared memory 和 named event,event reset 责任属于 CCLite。 -- CCLite 诊断报告字段变更必须同步 C API 测试、worker mock 测试和接口文档。 \ No newline at end of file +- CCLite 诊断报告字段变更必须同步 C API 测试、worker mock 测试和接口文档。 diff --git a/docs/09_release_history.md b/docs/09_release_history.md index 04d4889..0233130 100644 --- a/docs/09_release_history.md +++ b/docs/09_release_history.md @@ -1,6 +1,6 @@ # 09 版本历史与验收记录 -文档状态:0.6.4 版整理稿 +文档状态:0.6.5 版整理稿 ## 1. 版本线摘要 @@ -17,8 +17,35 @@ | 0.6.2 | 稳定性发布,不新增算法 | | 0.6.3 | 元素基础设施:`S4R`、受控 `C3D8R`、积分规则库、元素 introspection API | | 0.6.4 | CCLite coupling 基础闭环:中立 API、worker mock、Windows IPC adapter、surface/facet 扩展导出、节点力导入与诊断 | +| 0.6.5 | CCLite 真实 IPC worker 接入闭环:标准 worker 参数、AOR_V1 data block、能力查询和进程级 IPC 自测 | -## 2. 0.6.4 验收记录 +## 2. 0.6.5 验收记录 + +0.6.5 已完成: + +- `femlite --cclite-worker --worker-backend ipc` 真实 Windows IPC worker 后端。 +- `--solver-id`、`--timeout-ms`、`--worker-id`、`--command-block`、`--data-prefix` 等标准 worker 参数。 +- `--cclite-capabilities` 稳定 key=value 能力查询输出。 +- AOR_V1 data block 布局、初始化、校验和 C ABI 边界。 +- 真实进程级 1 step、100 step、timeout 和异常输入回归测试。 +- CCLite worker Fortran 2018 外围实现与 Fortran95 算法核心分层。 + +本地验收命令: +```powershell +cmake --build build-codex-gcc --parallel +ctest --test-dir build-codex-gcc --output-on-failure +ctest --test-dir build-codex-gcc -R "cclite_" --output-on-failure +git diff --check +``` + +结果: +- 完整编译通过。 +- 完整回归 78/78 通过。 +- CCLite/coupling 聚焦回归 8/8 通过。 +- `source_size` 通过。 +- `git diff --check` 通过。 + +## 3. 0.6.4 验收记录 0.6.4 已完成: @@ -42,7 +69,7 @@ git diff --check - 完整回归 73/73 通过。 - `git diff --check` 通过。 -## 3. 0.6.3 验收记录 +## 4. 0.6.3 验收记录 0.6.3 已完成: @@ -72,7 +99,7 @@ git diff --check - examples 精简后,`v5_acceptance` 34/34 通过。 - `git diff --check` 通过。 -## 4. 0.6.2 验收摘要 +## 5. 0.6.2 验收摘要 0.6.2 是稳定性发布,重点是 CSV schema、restart 诊断、contact/solver report、INP 错误边界和 CLI 输出目录边界。最终本地 gate 通过: @@ -83,13 +110,13 @@ git diff --check - version smoke。 - `git diff --check`。 -## 5. 0.6.0-0.6.1 验收摘要 +## 6. 0.6.0-0.6.1 验收摘要 0.6.0 引入 nonlinear lifecycle 和 rollback audit。0.6.1 在此基础上扩展 cutback taxonomy、`nonlinear_lifecycle.csv`、contact state counters、Riks/arc path 指标和线性求解器诊断字段。 这些版本不声明完整工业级 AL/mortar 一致切线、mixed-control continuation、cohesive 主线接触或 DEM/FEM 子循环。 -## 6. V5 验收摘要 +## 7. V5 验收摘要 V5 的长期验收入口保留为 `v5_acceptance` 标签。当前 examples 已精简,部分高难度历史示例不再作为当前示例交付项。 @@ -103,7 +130,7 @@ V5 当前文档口径主要覆盖: 已从当前 examples 中移除的历史难例包括:`strengthReduction`、`mohr_coulomb_yield_surface`、`ball_adhesion_decohesion`、`Dynamic_Grain_Packing_of_a_Flexible_Container`、`buckling_corrugated_shell`、`roll_forming`、`two_arches`、`block_on_arch`、`blasting_rock`、`failure_prediction_in_a_layered_shell`、`golfBallImpact`、`nonlinear_harmonic`、`stress_dependent_elasticity`、`cylinder_roller_contact`、`euler_column_buckling`、`membrane_airbag_inflation`、`pinched_hemispherical_shell`、`spherical_cap_with_central_point_load`。这些内容若后续恢复,应重新建立输入、checker 和 release gate。 -## 7. 历史文件合并说明 +## 8. 历史文件合并说明 以下旧文件内容已合并进本文档、`10_development_roadmap.md` 或 `11_benchmark_matrix.md`,因此不再单独维护: diff --git a/docs/10_development_roadmap.md b/docs/10_development_roadmap.md index 5edb3a0..82b46fb 100644 --- a/docs/10_development_roadmap.md +++ b/docs/10_development_roadmap.md @@ -1,6 +1,6 @@ # 10 后续开发路线图 -文档状态:0.6.4 版整理稿 +文档状态:0.6.5 版整理稿 ## 1. 路线图原则 @@ -44,21 +44,18 @@ 5. 大规模应用长算例继续留作后续版本。 ### 2.4 CCLite 联合改造 +CCLite 联合改造建议单独维护在 `docs/12_cclite_integration_suggestions.md`。总体原则是保持 FemLite 独立求解器身份,FemLite 只提供稳定 surface/facet 状态、外部载荷入口、worker 通信边界和诊断,不复制 CCLite 的 SPH-FEM/FSI 算法。 -CCLite 联合改造建议单独维护在 `docs/12_cclite_integration_suggestions.md`。总体原则是保持 FemLite 独立求解器身份,先固化中立 coupling API,再做 worker/service 和 IPC。 +0.6.5 已完成 CCLite coupling 基础闭环和真实 IPC worker 接入闭环:中立 coupling API、worker mock、Windows IPC adapter、surface/facet 扩展导出、节点力导入、诊断报告、标准 worker 参数、AOR_V1 data block、能力查询和进程级 IPC 自测。 建议优先级: -1. 中立 coupling API wrapper 和 C ABI smoke。 -2. 外部载荷缓存、总力/总力矩和拒绝记录诊断。 -3. worker/service mock transport 和命令状态机。 -4. Windows shared memory + named event adapter。 -5. surface/facet 完整导出、节点力导入和 CCLite 空耦合联调。 - -不建议直接把 CCLite 接触算法写入 FemLite,也不建议一开始就做真实 SPH-FEM 接触力验收。 - -0.6.4 已完成 CCLite coupling 基础闭环:中立 coupling API、worker mock、Windows IPC adapter、surface/facet 扩展导出、节点力导入、诊断报告和对应回归测试。真实 SPH-FEM penalty contact、FSI 与强耦合 rollback 仍保留为后续版本。 +1. surface/body id 稳定映射和 CCLite mock 联调。 +2. worker 诊断补强:跨求解器一致性字段、facet/load 对账和更完整错误分类。 +3. facet pressure 中立导入和更多 force balance 对账。 +4. 更长时间的 CCLite process-level 稳定性测试。 +不建议直接把 CCLite 接触算法写入 FemLite。真实 SPH-FEM penalty contact、FSI 与强耦合 rollback 仍保留为后续版本。 ## 3. 仍需延期的能力 - 完整 Abaqus keyword 兼容。 @@ -69,7 +66,7 @@ CCLite 联合改造建议单独维护在 `docs/12_cclite_integration_suggestions - 完整工业级 AL/mortar 一致切线。 - cohesive 主线接触。 - DEM/FEM 子循环。 -- CCLite worker/service、Windows IPC 和真实 SPH-FEM 联合验收。 +- 真实 SPH-FEM 联合物理验收、FSI 和强耦合 rollback。 - 大规模并行和内存优化。 ## 4. 版本规划建议 @@ -78,9 +75,10 @@ CCLite 联合改造建议单独维护在 `docs/12_cclite_integration_suggestions | 建议版本 | 目标 | |---|---| -| 0.6.5 | 用户侧积分选择或更完整 hourglass 控制二选一,不建议同时做 | -| 0.6.6 | 元素查询 API 文档化示例、更多 C API smoke、用户侧错误边界 | -| 0.7.0 | 壳/实体非线性能力提升、轻量 benchmark 闭环,或 CCLite worker mock 闭环二选一 | -| 0.7.x | 接触一致切线、cohesive 主线、CCLite IPC adapter 和应用 benchmark 按需恢复 | +| 0.6.5 | 已完成:真实 IPC worker 接入闭环、标准 worker 参数、data block AOR_V1、能力查询和自测 | +| 0.6.6 | 稳定 surface/body id 映射、process-level CCLite mock 联调和诊断字段补强 | +| 0.6.7 | facet pressure 中立导入、更多 force balance 对账 | +| 0.7.0 | 壳/实体非线性能力提升、轻量 benchmark 闭环,或 CCLite 联调增强二选一 | +| 0.7.x | 接触一致切线、cohesive 主线、CCLite 应用 benchmark 按需恢复 | 实际版本号应以当期风险和测试闭环为准。 diff --git a/docs/11_benchmark_matrix.md b/docs/11_benchmark_matrix.md index 37477f4..cdaa173 100644 --- a/docs/11_benchmark_matrix.md +++ b/docs/11_benchmark_matrix.md @@ -1,17 +1,17 @@ # 11 Benchmark 与验收矩阵 -文档状态:0.6.4 版整理稿 +文档状态:0.6.5 版整理稿 ## 1. 当前发布 Gate -0.6.4 发布 gate: +0.6.5 发布 gate: ```powershell cmake --build build-codex-gcc --parallel ctest --test-dir build-codex-gcc --output-on-failure git diff --check ``` -## 2. 0.6.4 矩阵 +## 2. 0.6.5 矩阵 | 领域 | 测试 | 验收点 | |---|---|---| @@ -22,7 +22,11 @@ git diff --check | IPC adapter | `cclite_ipc_adapter` | shared memory、named event、timeout、wait/signal、不 reset event | | IPC worker loop | `cclite_ipc_worker_loop` | transport facade 下 INIT 到 STOP 和 100 step 空耦合 | | VTU/PVD 输出 | `vtk_output` | 默认场变量 VTU/PVD 输出稳定 | -| 完整回归 | `ctest --output-on-failure` | 当前本地 73/73 通过 | +| 真实 IPC worker | `cclite_worker_process_1step` | 进程级 1 step 空耦合、seq/ack 和 STOP 闭环 | +| 真实 IPC worker 长闭环 | `cclite_worker_process_100step` | 进程级 100 step 空耦合稳定 | +| Worker 边界 | `cclite_worker_process_timeout` / `cclite_worker_process_badcase` | timeout 和异常输入可控退出 | +| Worker 能力查询 | `cclite_capabilities` | `--cclite-capabilities` 稳定 key=value 输出 | +| 完整回归 | `ctest --output-on-failure` | 当前本地 78/78 通过 | ## 3. V5 Acceptance 矩阵 | 领域 | 代表测试或 benchmark | diff --git a/docs/12_cclite_integration_suggestions.md b/docs/12_cclite_integration_suggestions.md index 47d3758..0b8ffb6 100644 --- a/docs/12_cclite_integration_suggestions.md +++ b/docs/12_cclite_integration_suggestions.md @@ -1,221 +1,233 @@ # 12 CCLite 联合改造建议 -文档状态:根据 `..\CCLite\femlite_suggests.md` 提取并按 FemLite 当前能力修订 +文档状态:根据 `..\CCLite\femlite_suggests.md` 新建议提取,并按 FemLite 0.6.5 当前能力修订。 -## 1. 改造口径 +## 1. 结论摘要 -FemLite 不建议改造成 CCLite 的内部库,也不建议把 CCLite 的 SPH-FEM 接触搜索、FSI 或调度算法复制进 FemLite。更合适的边界是: +CCLite 对 FemLite 的新建议已经从“建立基础 coupling API”推进到“真实 IPC worker 接入闭环”。FemLite 0.6.5 已经完成中立 coupling API、worker mock、Windows IPC adapter、surface/facet 扩展导出、节点力导入、诊断 CSV、真实 IPC worker、能力查询和对应回归测试,因此后续不应重复做这些基础项。 -- FemLite 保持独立求解器、独立 CLI、Fortran API 和 C ABI。 -- 新增一层面向 CCLite 的 worker/service adapter。 -- adapter 只负责命令、通信、数据映射、诊断和错误码。 -- FEM 侧只提供稳定 surface/facet 状态和外部载荷入口。 -- CCLite 负责联合调度、shared memory、named event、SPH-FEM 接触/耦合算法和联合诊断。 +0.6.5 已经保留现有 mock worker,同时新增真实 IPC worker 运行模式,让 `femlite.exe --cclite-worker --worker-backend ipc` 能按 CCLite 标准参数打开 command block、data block 和 named event,完成无 SPHLite 依赖的 attach、READY、空 facet/load、STOP 自测闭环。 -## 2. FemLite 当前已有基础 +真实 SPH-FEM penalty contact、FSI、tie/release 或强耦合 rollback 仍属于 CCLite 算法或后续联调层能力,不应作为 0.6.5 已完成能力声明。 -当前 FemLite 已具备一部分耦合基础,不应重复开发: - -- 已有边界 facet 查询能力:`fem_get_boundary_facet_count`、`fem_get_boundary_facets` 及 C ABI 对应接口。 -- 已有 facet 压力、traction、facet nodal load 入口和总力查询入口。 -- 已有元素 introspection API,可查询元素类型、节点、坐标、积分点、形函数、Jacobian 和 B 矩阵。 -- 已有接触、particle-facet、particle-FEM 相关模块和 smoke 测试,可作为后续联合验证基础。 -- 默认场变量输出已是 `result_XXXXXXXX.vtu` + `results.pvd`,适合 CCLite 联合结果检查。 - -这些能力目前仍偏内部或历史命名,例如 `sph` 前缀较多。后续建议先增加中立 coupling wrapper,而不是直接删改旧接口。 - -## 3. 必须保持的边界 +## 2. 必须保持的边界 FemLite 继续负责: - FEM 输入、网格、材料、section、边界条件解析。 - 实体/壳单元内力、质量、刚度和本构更新。 -- 显式动力学、静力、非线性静力、隐式 Newmark。 -- FEM 内部接触、cohesive、mortar/AL 等已有能力。 -- restart、CSV、VTU/PVD、诊断和自身 release gate。 +- 显式动力、线性静力、非线性静力、隐式 Newmark 等自身求解流程。 +- FemLite 内部接触、cohesive、mortar/AL 等已有能力。 +- restart、CSV、VTU/PVD、诊断、Fortran API、C ABI 和自身 release gate。 +- 稳定导出 FEM surface/facet 状态,并接收外部节点力等基础载荷。 -CCLite 负责: +CCLite 继续负责: - 启动、监控和停止 FemLite worker。 -- 创建和销毁 Windows shared memory 与 named event。 +- 创建、reset 和销毁 Windows shared memory 与 named event。 - 解析 CCLite 联合输入。 -- 读取 FemLite boundary facet 和 SPHLite 粒子状态。 +- 读取 FemLite facet 状态和 SPHLite 粒子状态。 - 计算 SPH-FEM 接触、FSI 或其他联合界面载荷。 -- 写回 FemLite 与 SPHLite 的外部载荷。 -- 输出联合诊断和力平衡报告。 +- 写回 FemLite 与 SPHLite 外部载荷。 +- 输出联合诊断、force balance 和跨求解器一致性报告。 -FemLite 不应: +FemLite 不应做: - 直接调度 SPHLite。 - 读取 SPHLite 私有数据结构。 - 链接 CCLite Fortran95 算法核心。 -- 在内部复制 CCLite 的 SPH-FEM 接触搜索算法。 -- reset 由 CCLite 创建并拥有的 event。 +- 复制 CCLite 的 SPH-FEM 接触搜索、耦合或 FSI 算法。 +- reset CCLite 创建并拥有的 event。 - 把 CCLite 预留能力描述成 FemLite 已完成物理算法。 -## 4. 推荐分阶段路线 +## 3. FemLite 0.6.4 已完成项 -### 4.1 阶段 A:中立 coupling API 固化 +0.6.4 已经覆盖 CCLite 建议中的基础闭环: -目标是把已有 facet/load 能力整理为 CCLite 可稳定依赖的公共接口,不引入 worker IPC。 +- 中立 coupling surface/facet wrapper 和 C ABI。 +- 旧 `boundary` 与 `sph` 命名接口继续兼容。 +- surface/facet 扩展导出字段:`surface_id`、`material_id`、`section_id`、`valid_flags`、`shell_thickness`、`mass_per_area`。 +- 按 `*SURFACE, NAME=..., TYPE=ELEMENT` 名称过滤导出。 +- 退化 facet invalid flag、normal 单位化、实体面厚度为 0、壳厚度和面密度测试。 +- coupling 节点力导入,包含 `source_id`、`load_mode`、`valid_flags`。 +- 独立 external load cache,`fem_clear_coupling_loads` 统一清理本步载荷和诊断。 +- 节点力已叠加到显式动力外力、线性静力 RHS 和隐式/非线性外力装配路径。 +- 本步总力、总力矩、接受记录、非有限载荷、未知节点和容量/metadata 拒绝计数。 +- 按 `source_id` 汇总诊断。 +- `femlite_cclite_load_report.csv` 和 `femlite_cclite_surface_report.csv`。 +- worker mock 命令状态机,覆盖 `INIT`、`READ_INPUT`、`BUILD_MODEL`、`EXPORT_INTERFACE`、`IMPORT_LOADS`、`ADVANCE`、`WRITE_OUTPUT`、`STOP`。 +- worker mock 100 step 空耦合、seq/ack、STOP、错误路径、VTU/PVD 与诊断 CSV 一致性测试。 +- Windows shared memory / named event C adapter,提供 open/wait/signal/close,不 reset event。 +- transport facade 的 mock 与 Windows IPC backend 小闭环测试。 -建议内容: +这些能力是后续真实 IPC worker 的基础,不需要重写。 -- 新增或文档化中立命名 C ABI,例如 `femlite_get_coupling_surface_count`、`femlite_get_coupling_surface_facets`、`femlite_apply_coupling_nodal_forces`。 -- 旧 `sph` 命名接口保留为兼容 wrapper。 -- 明确数组展开方式、容量不足返回、无效 id 返回和非有限载荷拒绝。 -- 增加 coupling load 总力、总力矩、拒绝记录数、节点未匹配数查询。 -- 增加 C API smoke,覆盖 facet 导出、空载荷、节点力和错误边界。 +## 4. 新建议提取与修订 -建议先作为 0.6.x 小版本完成。 +### 4.1 标准 worker 参数 -当前实现状态: - -- 已新增中立 surface count/facets wrapper,阶段 A 暂导出全部边界 facet。 -- 已新增中立 nodal force wrapper,复用现有外部耦合力向量。 -- 已新增 coupling load 诊断,可查询总力、总力矩、接受记录数、非有限载荷拒绝数、未知节点拒绝数和容量/metadata 拒绝数。 -- 已补充 C API smoke,覆盖 surface count、三角形/四边形 facet 导出、当前坐标/速度导出、空载荷、节点力、非有限载荷、未知节点和容量错误。 -- surface 名称过滤、壳厚度、mass per area 和更完整 surface 字段仍留在后续阶段。 - -### 4.2 阶段 B:worker 协议 smoke - -目标是让 FemLite 具备 worker 主循环和命令状态机,但通信层先使用 mock transport 或文件/内存模拟,避免一开始就把 Windows IPC 和求解流程耦合在一起。 - -建议命令: +CCLite 新建议要求支持: ```text -INIT -READ_INPUT -BUILD_MODEL -EXPORT_INTERFACE -IMPORT_LOADS -ADVANCE -WRITE_OUTPUT -STOP +femlite.exe --cclite-worker --solver-id FEM --case femlite.inp --ipc-name CCLITE_CASE001 --timeout-ms 30000 ``` -完成标准: +并预留: -- `femlite.exe --cclite-worker --case femlite.inp --ipc-name ` 可进入 worker 模式。 -- 未指定 `--cclite-worker` 时原 CLI 行为完全不变。 -- worker 可进入 `READY`、响应 `STOP`、写错误码和日志。 -- mock 传输可完成 100 step 空耦合。 +```text +--command-block +--data-prefix +--log +--timeout-ms +--worker-id +``` -当前实现状态: +FemLite 修订建议: -- 已新增 `fem_cclite_worker` mock worker,内部命令覆盖 `INIT`、`READ_INPUT`、`BUILD_MODEL`、`EXPORT_INTERFACE`、`IMPORT_LOADS`、`ADVANCE`、`WRITE_OUTPUT` 和 `STOP`。 -- 已新增 worker command block,包含 `seq`、`ack_seq`、`command_id`、`step_id`、`substep_id`、`iteration_id`、`worker_state` 和 `error_code`。 -- 已新增 `--cclite-worker` CLI 入口,支持 `--case`、`--ipc-name`、`--log`、`--output-dir` 和 `--mock-steps`。 -- 已新增 CSV 风格 worker 日志,记录启动参数、命令状态和错误码。 -- 已补充 `cclite_worker_mock` 回归测试,覆盖 READY、seq/ack、100 step 空耦合、VTU/PVD 输出、STOP 和输入错误路径。 -- 当前仍是 mock 协议闭环,不是真实 Windows shared memory/named event IPC。 +- 保留当前 `--cclite-worker --case --ipc-name --log --output-dir --mock-steps`,避免破坏 0.6.4 回归。 +- 新增 `--solver-id`、`--timeout-ms`、`--command-block`、`--data-prefix`、`--worker-id`。 +- 增加模式区分:`--mock-steps` 存在或显式 `--worker-backend mock` 时运行 mock worker;指定真实 IPC backend 时打开 CCLite 对象。 +- `--solver-id` 初期只接受 `FEM` 或 `FEMLite`,不把求解器类型泛化成插件系统。 -### 4.3 阶段 C:Windows IPC adapter +优先级:高,适合下一版。 -目标是接入 CCLite 创建的 command block、data block、named event。 +### 4.2 真实 IPC worker 主循环 -建议边界: +CCLite 新建议要求 worker 启动后打开 CCLite 创建的 command block、data block、command event、done event,进入 READY,随后 wait command、执行命令、写回 ack/state/error 并 signal done。 -- FemLite 只 open CCLite 创建的对象。 +FemLite 修订建议: + +- 复用 0.6.4 的 `femlite_cclite_transport` facade,不另起一套 IPC 代码。 +- 将现有 mock worker 的命令处理逻辑抽成 backend 无关的命令执行器。 +- 第一阶段只闭合真实 IPC 下的 `INIT`、`READ_INPUT`、`BUILD_MODEL`、`EXPORT_INTERFACE`、`IMPORT_LOADS` 空载荷、`ADVANCE` 空耦合、`WRITE_OUTPUT`、`STOP`。 - FemLite 只 wait/signal,不 reset event。 -- command block 必须包含 `seq`、`ack_seq`、`command_id`、`step_id`、`substep_id`、`iteration_id`、`error_code`。 -- 0.1.x 可固定 `substep_id=0`、`iteration_id=0`。 -- IPC 错误必须写 worker 日志和稳定错误码。 +- 非 Windows 继续返回 unsupported,并保留 mock worker 可运行。 -该阶段建议只验收空 facet 或少量固定 facet 导出,不验收真实 SPH-FEM 接触力。 +优先级:最高,适合下一版作为主目标。 -当前实现状态: +### 4.3 data block 与数据布局 -- 已新增 `femlite_cclite_ipc.h` 和 C adapter,定义稳定 command block 布局、命令枚举、状态枚举和 IPC 错误码。 -- 已新增 shared memory open/close wrapper,Windows 下只打开 CCLite 已创建对象,非 Windows 返回 unsupported。 -- 已新增 named event open/wait/signal/close wrapper,wait/signal 不 reset event。 -- 已新增 `femlite_cclite_wait_command` 和 `femlite_cclite_write_done`,支持等待 `COMMAND_EVENT` 后读取 command block,并写回 ack/state/error 后 signal `DONE_EVENT`。 -- 已新增 `femlite_cclite_transport` facade,提供 mock 与 Windows IPC 两个 backend 的统一 receive/complete 入口。 -- 已补充 `cclite_ipc_adapter` smoke,覆盖命名、布局、open、timeout、wait/signal 和 event 不 reset。 -- 已补充 `cclite_ipc_worker_loop` smoke,使用本地测试 helper 模拟 CCLite,并通过 transport facade 完成 INIT 到 STOP 和 100 step 空耦合。 -- 当前尚未把 `femlite.exe --cclite-worker` 主循环切换为真实跨进程 Windows IPC 运行模式;现阶段先固化 adapter 和 transport 小闭环。 +CCLite 新建议明确要求打开 data block,并优先闭合 `FEM_TO_CCL_FACET` 与 `CCL_TO_FEM_LOAD`。 -### 4.4 阶段 D:真实 surface/facet 导出 +FemLite 修订建议: -目标是让 CCLite 能读取稳定 FEM 边界状态。 +- 新增明确版本化布局,例如 `AOR_V1`。 +- `FEM_TO_CCL_FACET` 先支持 header + facet records,字段来自现有扩展导出。 +- `CCL_TO_FEM_LOAD` 先支持 header + nodal force records,字段映射到现有 coupling 节点力导入。 +- data block 由 CCLite 创建和定容,FemLite 只 open、检查版本和容量、读写合法范围。 +- 如果容量不足,FemLite 返回稳定错误码并写 worker 日志,不截断静默成功。 -最小字段: +优先级:高,适合与真实 IPC worker 同版完成最小闭环。 -- `facet_id` -- `surface_id` -- `elem_id` -- `face_id` -- `node_count` -- `node_ids` -- 当前节点坐标 -- 当前节点速度 -- facet normal -- facet area -- material id -- section id -- valid flags +### 4.4 surface/facet 字段 -壳单元扩展字段: - -- shell thickness -- mass per area - -实体面 `shell_thickness=0`。退化 facet 应设置 invalid flag,不应静默导出为有效接触面。 - -当前实现状态: - -- 已新增 coupling surface 扩展导出接口,保留旧 ABI,同时输出 `surface_id`、`material_id`、`section_id`、`valid_flags`、`shell_thickness` 和 `mass_per_area`。 -- 未指定 surface 时继续导出全部边界 facet,`surface_id=0` 并写 warning。 -- 已支持按已有 `*SURFACE, NAME=..., TYPE=ELEMENT` 名称过滤导出。 -- 已补充单三角形、单四边形、退化三角形、退化四边形、实体面厚度为 0、壳厚度、面密度和 normal 单位化 smoke。 -- 当前 surface_id 使用内部 surface 序号;若 CCLite 需要稳定跨文件 ID,后续可增加显式映射表。 - -### 4.5 阶段 E:外部载荷导入与诊断 - -目标是支持 CCLite 写回的节点力,并安全叠加到 FemLite 求解流程。 - -建议先只做: - -- `NODAL_FORCE` -- `node_id` -- `force[3]` -- `source_id` -- `load_mode` -- `valid_flags` - -FemLite 内部应有独立外部耦合载荷缓存。每个 CCLite step 开始前清零,导入后再叠加到当前求解步外力或 RHS。不要让 CCLite 直接写 FemLite 全局力数组。 - -诊断至少包括: - -- 本步接收总力。 -- 本步接收总力矩。 -- 每个 surface 的总载荷。 -- 被拒绝的 load record 数量。 -- 非有限载荷数量。 -- 节点 id 未匹配数量。 - -当前实现状态: - -- 已新增独立 coupling external load 缓存,并通过 `fem_clear_coupling_loads` 统一清理本步载荷和诊断。 -- coupling 节点力已叠加到显式动力外力路径、静力线性 RHS 和隐式/非线性外力装配路径。 -- 已校验 `source_id`、`load_mode`、`valid_flags`、非有限载荷和未知节点,拒绝记录会进入诊断计数。 -- 已提供本步总力、总力矩、按 `source_id` 汇总的诊断查询。 -- 已输出 `femlite_cclite_load_report.csv` 与 `femlite_cclite_surface_report.csv`,worker mock 在写 VTU/PVD 时同步写出两份报告。 -- 已补充显式单步响应、静力 RHS 响应、force balance CSV 和 worker 输出一致性回归测试。 -- 当前仍是基础节点力闭环,不包含真实 SPH-FEM penalty contact、FSI 或 CCLite 强耦合 rollback。 - -## 5. 输入与 surface 语义建议 - -FemLite 自身输入仍由 FemLite 解析。建议优先复用或加强已有 `*SURFACE`/接触 surface 解析能力,而不是新增另一套不兼容语法。 - -建议目标: +CCLite 建议字段包括: ```text -*SURFACE, NAME=CCL_SURF_PLATE, TYPE=ELEMENT -... +facet_id, surface_id, elem_id, face_id, node_count, node_ids, +x_node, v_node, normal, area, shell_thickness, mass_per_area, +material_id, section_id, body_id, valid_flags ``` -可选增加辅助关键词: +FemLite 当前已完成除 `body_id` 外的主要字段。 + +FemLite 修订建议: + +- `body_id` 不应临时伪造为材料号、section 号或 element set 号。 +- 下一步可先定义 `body_id=0` 的占位规则并文档化,或增加显式 body/part 映射表后再输出真实稳定 ID。 +- 继续保持实体面 `shell_thickness=0`、`mass_per_area=0`。 +- 继续让退化 facet 进入导出但标记 `valid_flags=0`,便于诊断。 +- 如果 CCLite 需要跨文件稳定 surface id,应新增显式 surface id 映射表,而不是依赖内部 surface 序号。 + +优先级:中高。`body_id` 和稳定 surface id 可在真实 IPC data block 之后做。 + +### 4.5 外部载荷导入 + +CCLite 建议基础载荷为: + +```text +node_id +force[3] +source_id +load_mode +distribution_mode +valid_flags +``` + +并预留: + +```text +FACET_PRESSURE +MOMENT +KINEMATIC_BOUNDARY +``` + +FemLite 当前已支持节点力、source/load_mode/valid_flags、总力/总力矩和诊断 CSV。 + +FemLite 修订建议: + +- 下一步在 data block 中增加 `step_id`、`record_id`、`distribution_mode` 字段,但 Fortran 求解侧暂不必使用 `distribution_mode`。 +- `MOMENT` 不应直接假装已支持。若要支持,应先明确转动自由度、壳/实体节点 DOF 映射和静力/动力 RHS 规则。 +- `FACET_PRESSURE` 可复用历史 facet pressure 能力,但需要中立 coupling API 和 data block 记录格式后再开放。 +- `KINEMATIC_BOUNDARY` 风险较高,涉及约束生命周期和求解器一致性,应延期。 + +优先级:节点力 data block 高;facet pressure 中;moment/kinematic boundary 暂缓。 + +### 4.6 诊断和 force balance + +CCLite 建议 worker 至少输出启动参数、command block 名称、data block 名称、command id、step id、ack seq、worker state、facet 数、load 数、总力、总力矩、错误码和错误消息。 + +FemLite 当前已有 worker log、load report、surface report,但还缺真实 IPC 对象名称、data block 名称和短错误消息字段。 + +FemLite 修订建议: + +- 扩展 worker log header:记录 backend、solver_id、worker_id、ipc_name、command_block、data_prefix、timeout_ms。 +- 扩展每条命令日志:记录 command_id、step_id、substep_id、iteration_id、state、error_code、短错误消息。 +- 在 `WRITE_OUTPUT` 或每步结束时同步输出 facet/load 诊断。 +- 保持报告文件名: + - `femlite_cclite_worker.log` + - `femlite_cclite_surface_report.csv` + - `femlite_cclite_load_report.csv` +- 不把 CCLite 的联合 `force_balance.csv` 直接写进 FemLite;FemLite 提供原始统计,由 CCLite 生成跨求解器 force balance。 + +优先级:高,适合真实 IPC worker 同版完成。 + +### 4.7 能力查询入口 + +CCLite 新建议增加: + +```text +femlite.exe --cclite-capabilities +``` + +建议输出: + +```text +solver=FEMLite +cclite_worker=yes +worker_mock=yes/no +ipc_backend=windows_shmem_named_event +command_block_version=1 +data_layout=AOR_V1 +supports_real_ipc=yes/no +supports_fem_to_ccl_facet=yes/no +supports_ccl_to_fem_load=yes/no +max_facet_records=... +max_load_records=... +``` + +FemLite 修订建议: + +- 建议新增该 CLI,输出稳定 key=value 文本,方便 CCLite 解析。 +- 同步提供 C ABI 能力查询不是必须,可后置。 +- `supports_real_ipc` 在真实 worker 主循环完成前必须输出 `no`,避免误判。 +- `max_facet_records`、`max_load_records` 初期可输出编译期常量或 `0` 表示由 CCLite data block 容量决定。 + +优先级:高,成本低,适合下一版。 + +### 4.8 输入关键字 + +CCLite 建议 FemLite 可选支持: ```text *FEMLITE CCLITE @@ -226,78 +238,100 @@ EXPORT_THICKNESS=YES ACCEPT_EXTERNAL_LOAD=YES ``` -该关键词只作为 FemLite 侧辅助配置,不替代 CCLite 联合输入。 +FemLite 修订建议: -## 6. 测试建议 +- 不建议把它作为下一版主线。真实 worker 的命令行和 IPC data block 优先级更高。 +- 若要做,应只作为 FemLite 侧辅助配置,不替代 CCLite 联合输入。 +- `EXPORT_SURFACE` 可映射到已有 surface 名称过滤。 +- 不应在 input keyword 中声明真实 SPH-FEM 接触算法已经启用。 -阶段 A 测试: +优先级:中低,建议在真实 IPC worker 闭环后再做。 -- C ABI coupling surface count。 -- 三角形 facet 导出。 -- 四边形 facet 导出。 -- 当前坐标和速度导出。 -- 空载荷导入。 -- 节点力导入。 -- 容量不足错误。 -- 非有限载荷拒绝。 -- 节点 id 未匹配错误。 +### 4.9 自测和联调路径 -阶段 B/C 测试: +CCLite 新建议要求在没有 SPHLite 的情况下验证 worker 启动、IPC attach、READY、空 facet、空 load、STOP。 -- worker 启动。 -- `READY` 状态。 -- command seq/ack。 -- wait/signal,不 reset event。 -- 100 step 空耦合。 -- `STOP` 正常退出。 -- 超时和错误码。 +FemLite 修订建议: -阶段 D/E 联合测试: +- 新增真实 IPC self-test,使用本地测试 helper 创建 shared memory/event,启动或调用 FemLite worker,验证 INIT 到 STOP。 +- 测试分三层: + - adapter 单元测试:open/wait/signal/no reset/timeout。 + - in-process transport 测试:command block 与 100 step 空耦合。 + - process-level worker 测试:`femlite.exe --cclite-worker --worker-backend ipc` 真实进程 attach。 +- 与 CCLite 联调先验收三类路径: + - mock SPH + 真实 FemLite,1 step 空耦合。 + - mock SPH + 真实 FemLite,100 step 空耦合。 + - 异常输入和 timeout 可控退出。 -- 单三角形 facet。 -- 单四边形 facet。 -- 壳厚度导出。 -- 单粒子撞面。 -- 多粒子压面。 -- force balance CSV 对账。 -- VTU/PVD 场输出和 worker 诊断文件一致性检查。 +优先级:最高,真实 IPC worker 必须配套。 -可复用算例: +## 5. 逐条响应 CCLite 建议 -- `contact_rigid_plane_indentation` -- `shell_rigid_plane_contact` -- `shell_solid_contact` -- `clamped_square_plate_pressure_pulse` -- `rigid_sphere_impact_plate` +| CCLite 建议 | FemLite 0.6.5 状态 | 修订响应 | +|---|---|---| +| 保持 FemLite 独立 worker/service,不嵌入 CCLite 算法 | 已遵守 | 继续保持,adapter 只做通信和数据映射 | +| 支持 `--cclite-worker` | 已支持 mock worker 和真实 IPC backend | 继续保持两种 backend | +| 打开 command block | 已通过真实 IPC worker 接入 | 继续保持小闭环回归 | +| 打开 data block | 已定义 `AOR_V1` 并接入 facet/load block | 后续扩展更多记录类型 | +| wait `COMMAND_EVENT` / signal `DONE_EVENT` | 已在真实 worker 中使用 | 继续保持不 reset event 约束 | +| 不 reset event | 已遵守 | 继续作为接口约束和测试项 | +| 支持 INIT 到 STOP 命令 | mock 与真实 IPC worker 已支持 | 继续复用同一命令执行器 | +| `substep_id=0`、`iteration_id=0` | 已有字段 | 真实 IPC worker 初期继续固定为 0 | +| 导出空或固定 facet | 已通过 data block 支持空/fixed facet 边界 | 后续接入更完整 surface/body 映射 | +| 接收空载荷 | 已支持 | 继续保持空载荷自测 | +| 接收节点力 | API 与求解路径已支持,`CCL_TO_FEM_LOAD` 已接入 | 后续扩展更多载荷类型 | +| 输出 worker 日志和接口诊断 | 已补充 backend、IPC 名称、data block 名称和短错误消息 | 后续补强跨求解器对账字段 | +| 导出 shell thickness/mass per area | 已支持并加入 data block | 继续保留 | +| 导出 body_id | 未支持 | 暂用 `0` 占位或后续显式 body 映射,不伪造 | +| 稳定 surface id | 当前为内部序号 | 后续增加显式映射表 | +| 支持 facet pressure | 历史内部能力存在,中立 CCLite block 未接 | 后续单独做,不与真实 IPC worker 混在同一最小闭环 | +| 支持 moment | 未支持 | 暂缓,需要 DOF/RHS 语义设计 | +| 支持 kinematic boundary | 未支持 | 暂缓,风险较高 | +| `--cclite-capabilities` | 已支持 | 保持 key=value 输出稳定 | +| 无 SPHLite 自测 | 已补 process-level 真实 IPC 自测 | 后续可增加 CCLite mock 联调 | +| 不把 mock 当真实耦合完成 | 文档已说明 | 继续明确区分 mock worker 与 real IPC worker | -## 7. 建议版本切分 +## 6. 0.6.5 完成范围 + +0.6.5 已按“真实 IPC worker 接入闭环”落地以下范围: + +1. CLI 参数补齐:`--solver-id`、`--timeout-ms`、`--command-block`、`--data-prefix`、`--worker-id`、`--worker-backend`。 +2. `--cclite-capabilities` key=value 输出。 +3. worker 命令执行器与 transport backend 解耦。 +4. 真实 Windows IPC worker 主循环接入 command block/event。 +5. 定义 `FEM_TO_CCL_FACET` data block `AOR_V1` header 和最小 facet records。 +6. 定义 `CCL_TO_FEM_LOAD` data block `AOR_V1` header 和空/nodal force records。 +7. worker log 增加 backend、IPC 名称、data block 名称和短错误消息。 +8. process-level self-test 覆盖 attach、READY、空 facet、空 load、STOP、timeout 和异常输入。 +9. 文档更新,明确 mock worker、IPC adapter、real IPC worker 三者边界。 + +该版本不建议包含: + +- 真实 SPH-FEM penalty contact 物理验收。 +- FSI 工程算例。 +- tied/release。 +- rollback 或预测状态接口。 +- facet pressure 的完整物理验收。 +- kinematic boundary。 +- 删除旧 `sph` 命名接口。 + +## 7. 建议版本路线 | 建议版本 | FemLite 目标 | |---|---| -| 0.6.x | 中立 coupling API wrapper、文档、C ABI smoke、外部载荷诊断框架 | -| 0.7.0 | worker/service mock transport、命令状态机、空耦合闭环 | -| 0.7.1 | Windows shared memory + named event adapter、CCLite 空耦合联调 | -| 0.7.2 | surface/facet 完整导出、节点力导入、force/moment 诊断 | -| 0.7.x 后续 | shell thickness、mass per area、surface id 稳定化、pressure/facet load | -| 0.8.x | tie/release、rollback/强耦合预留、长时间稳定性 | -| 0.9.x | FSI 工程简化算例、性能基线和异常处理补强 | +| 0.6.4 | 已完成:中立 coupling API、worker mock、IPC adapter、surface/facet 扩展导出、节点力导入与诊断 | +| 0.6.5 | 已完成:真实 IPC worker 接入闭环、标准 worker 参数、data block AOR_V1、能力查询、自测 | +| 0.6.6 | 推荐:稳定 surface/body id 映射、process-level CCLite mock 联调和诊断字段补强 | +| 0.6.7 | 可选:facet pressure 中立导入、更多 force balance 对账 | +| 0.7.x | tied/release、rollback 预留、弱/强耦合策略、长时间稳定性 | +| 0.8.x | FSI 和工程化联合算例 | -## 8. 不建议立即做的事项 +## 8. 最终建议 -- 不建议把 CCLite 接触算法移入 FemLite。 -- 不建议 FemLite 直接链接 CCLite 核心库。 -- 不建议一开始就做真实 SPH-FEM penalty contact 验收。 -- 不建议 worker IPC、真实载荷导入、surface 名称稳定化和强耦合 rollback 一次性开发。 -- 不建议删除旧 `sph` 命名接口,应先提供中立 wrapper 并保留兼容期。 +CCLite 新建议中,0.6.5 已完成的“真实 IPC worker 接入闭环”直接承接 0.6.4 的 adapter、mock worker、surface/load API 和诊断能力,能让 CCLite 明确区分: -## 9. 推荐下一步 +- `worker mock`:FemLite 内部顺序执行命令的测试模式。 +- `IPC adapter`:C 层 shared memory/event 操作封装。 +- `real IPC worker`:真正由 CCLite command/event 驱动的 worker 运行模式。 -最稳的小闭环是先做阶段 A: - -1. 盘点现有 boundary facet 与 sph load API。 -2. 增加中立 coupling wrapper。 -3. 增加 coupling load 诊断。 -4. 补 C ABI smoke。 -5. 更新接口文档。 - -完成后再进入 worker/service,而不是直接上 Windows IPC。 +真实 IPC worker、data block 和 process-level self-test 已在 0.6.5 形成最小闭环;但它仍只是通信和数据边界验收,不等同于真实 SPH-FEM 接触物理验收。 diff --git a/docs/README.md b/docs/README.md index 78ae8e5..9b74d0b 100644 --- a/docs/README.md +++ b/docs/README.md @@ -1,6 +1,6 @@ # FemLite 文档索引 -文档状态:0.6.4 版整理稿 +文档状态:0.6.5 版整理稿 ## 核心文档 @@ -18,6 +18,8 @@ - [09 版本历史与验收记录](09_release_history.md) - [10 后续开发路线图](10_development_roadmap.md) - [11 Benchmark 与验收矩阵](11_benchmark_matrix.md) +- [12 CCLite 联合改造建议](12_cclite_integration_suggestions.md) +- [13 CCLite Coupling API 盘点](13_cclite_coupling_api_inventory.md) ## 维护说明 diff --git a/include/femlite_cclite_ipc.h b/include/femlite_cclite_ipc.h index 6b1f611..2c6bb65 100644 --- a/include/femlite_cclite_ipc.h +++ b/include/femlite_cclite_ipc.h @@ -38,6 +38,14 @@ extern "C" { #define FEMLITE_CCL_BACKEND_MOCK 1 #define FEMLITE_CCL_BACKEND_WINDOWS_IPC 2 +#define FEMLITE_CCL_ERROR_MESSAGE_CAPACITY 128 + +#define FEMLITE_CCL_DATA_MAGIC 0x46434c44 +#define FEMLITE_CCL_DATA_LAYOUT_AOR_V1 1 +#define FEMLITE_CCL_DATA_RECORD_FEM_TO_CCL_FACET 1 +#define FEMLITE_CCL_DATA_RECORD_CCL_TO_FEM_LOAD 2 +#define FEMLITE_CCL_DATA_MAX_FACET_NODES 8 + typedef struct femlite_cclite_command_block { int32_t version; int32_t seq; @@ -48,8 +56,55 @@ typedef struct femlite_cclite_command_block { int32_t iteration_id; int32_t worker_state; int32_t error_code; + char error_message[FEMLITE_CCL_ERROR_MESSAGE_CAPACITY]; } femlite_cclite_command_block; +typedef struct femlite_cclite_data_header { + int32_t magic; + int32_t version; + int32_t layout; + int32_t record_type; + int32_t record_capacity; + int32_t record_count; + int32_t record_stride; + int32_t status_code; + int32_t error_code; + int32_t reserved[7]; + char error_message[FEMLITE_CCL_ERROR_MESSAGE_CAPACITY]; +} femlite_cclite_data_header; + +typedef struct femlite_cclite_facet_record_aor_v1 { + int32_t facet_id; + int32_t surface_id; + int32_t elem_id; + int32_t face_id; + int32_t node_count; + int32_t node_ids[FEMLITE_CCL_DATA_MAX_FACET_NODES]; + int32_t material_id; + int32_t section_id; + int32_t body_id; + int32_t valid_flags; + double x_node[3 * FEMLITE_CCL_DATA_MAX_FACET_NODES]; + double v_node[3 * FEMLITE_CCL_DATA_MAX_FACET_NODES]; + double normal[3]; + double area; + double shell_thickness; + double mass_per_area; +} femlite_cclite_facet_record_aor_v1; + +typedef struct femlite_cclite_load_record_aor_v1 { + int32_t record_id; + int32_t step_id; + int32_t node_id; + int32_t source_id; + int32_t load_mode; + int32_t distribution_mode; + int32_t valid_flags; + int32_t reserved; + double force[3]; + double moment[3]; +} femlite_cclite_load_record_aor_v1; + typedef struct femlite_cclite_map { void *handle; void *view; @@ -75,6 +130,14 @@ typedef struct femlite_cclite_transport { size_t femlite_cclite_command_block_size(void); void femlite_cclite_init_command_block(femlite_cclite_command_block *block); +size_t femlite_cclite_data_header_size(void); +size_t femlite_cclite_facet_record_aor_v1_size(void); +size_t femlite_cclite_load_record_aor_v1_size(void); +void femlite_cclite_init_data_header(femlite_cclite_data_header *header, + int32_t record_type, + int32_t record_capacity, + int32_t record_stride); +int femlite_cclite_windows_ipc_available(void); int femlite_cclite_format_name(const char *prefix, const char *suffix, char *out_name, size_t out_capacity); @@ -100,6 +163,10 @@ int femlite_cclite_write_done(femlite_cclite_event *done_event, int femlite_cclite_transport_init_mock(femlite_cclite_transport *transport); int femlite_cclite_transport_open_windows(const char *prefix, femlite_cclite_transport *transport); +int femlite_cclite_transport_open_windows_ex( + const char *prefix, + const char *command_block_name, + femlite_cclite_transport *transport); int femlite_cclite_transport_close(femlite_cclite_transport *transport); int femlite_cclite_transport_mock_push( femlite_cclite_transport *transport, diff --git a/src/app/fem_program.f90 b/src/app/fem_program.f90 index 2677447..8046aca 100644 --- a/src/app/fem_program.f90 +++ b/src/app/fem_program.f90 @@ -47,7 +47,6 @@ program femlite integer :: output_interval_arg integer :: linear_iter_limit integer :: buckling_mode_count - integer :: worker_mock_steps integer :: ios real(rk) :: time real(rk) :: res_norm @@ -58,10 +57,9 @@ program femlite character(len=256) :: filename character(len=256) :: arg character(len=256) :: output_dir_arg - character(len=256) :: worker_case_arg - character(len=256) :: worker_ipc_arg - character(len=256) :: worker_log_arg - character(len=256) :: worker_output_arg + character(len=256) :: worker_backend_upper + character(len=256) :: solver_id_upper + type(ccl_worker_options) :: worker_options logical :: do_run logical :: do_static_linear logical :: do_static_nonlinear @@ -85,18 +83,24 @@ program femlite call fem_get_version(major, minor, patch, ierr) call exit_if_error(ierr) - write(*,'(A,I1,A,I1,A,I1)') 'FemLite ', major, '.', minor, '.', patch - argc = iargc() if (argc .ge. 1) then call getarg(1, filename) + if (trim(filename) .eq. '--cclite-capabilities') then + call ccl_worker_write_capabilities() + call fem_finalize(ierr) + call exit_if_error(ierr) + call exit(0) + end if + + write(*,'(A,I1,A,I1,A,I1)') 'FemLite ', major, '.', minor, '.', patch + if (trim(filename) .eq. '--cclite-worker') then - worker_case_arg = ' ' - worker_ipc_arg = 'mock' - worker_log_arg = ' ' - worker_output_arg = ' ' - worker_mock_steps = 0 + worker_options = ccl_worker_options() + worker_options%case_file = ' ' + worker_options%ipc_name = 'mock' + worker_options%worker_backend = 'ipc' iarg = 2 do while (iarg .le. argc) call getarg(iarg, arg) @@ -107,7 +111,7 @@ program femlite call exit(2) end if iarg = iarg + 1 - call getarg(iarg, worker_case_arg) + call getarg(iarg, worker_options%case_file) else if (trim(arg) .eq. '--ipc-name') then if (iarg + 1 .gt. argc) then write(*,'(A)') 'missing value after --ipc-name' @@ -115,7 +119,7 @@ program femlite call exit(2) end if iarg = iarg + 1 - call getarg(iarg, worker_ipc_arg) + call getarg(iarg, worker_options%ipc_name) else if (trim(arg) .eq. '--log') then if (iarg + 1 .gt. argc) then write(*,'(A)') 'missing value after --log' @@ -123,7 +127,7 @@ program femlite call exit(2) end if iarg = iarg + 1 - call getarg(iarg, worker_log_arg) + call getarg(iarg, worker_options%log_path) else if (trim(arg) .eq. '--output-dir') then if (iarg + 1 .gt. argc) then write(*,'(A)') 'missing value after --output-dir' @@ -131,7 +135,61 @@ program femlite call exit(2) end if iarg = iarg + 1 - call getarg(iarg, worker_output_arg) + call getarg(iarg, worker_options%output_dir) + else if (trim(arg) .eq. '--solver-id') then + if (iarg + 1 .gt. argc) then + write(*,'(A)') 'missing value after --solver-id' + call fem_finalize(ierr) + call exit(2) + end if + iarg = iarg + 1 + call getarg(iarg, worker_options%solver_id) + else if (trim(arg) .eq. '--timeout-ms') then + if (iarg + 1 .gt. argc) then + write(*,'(A)') 'missing value after --timeout-ms' + call fem_finalize(ierr) + call exit(2) + end if + iarg = iarg + 1 + call getarg(iarg, arg) + read(arg,*,iostat=ios) worker_options%timeout_ms + if (ios .ne. 0 .or. worker_options%timeout_ms .le. 0) then + write(*,'(A,A)') 'invalid --timeout-ms value: ', trim(arg) + call fem_finalize(ierr) + call exit(2) + end if + else if (trim(arg) .eq. '--worker-id') then + if (iarg + 1 .gt. argc) then + write(*,'(A)') 'missing value after --worker-id' + call fem_finalize(ierr) + call exit(2) + end if + iarg = iarg + 1 + call getarg(iarg, worker_options%worker_id) + else if (trim(arg) .eq. '--command-block') then + if (iarg + 1 .gt. argc) then + write(*,'(A)') 'missing value after --command-block' + call fem_finalize(ierr) + call exit(2) + end if + iarg = iarg + 1 + call getarg(iarg, worker_options%command_block) + else if (trim(arg) .eq. '--data-prefix') then + if (iarg + 1 .gt. argc) then + write(*,'(A)') 'missing value after --data-prefix' + call fem_finalize(ierr) + call exit(2) + end if + iarg = iarg + 1 + call getarg(iarg, worker_options%data_prefix) + else if (trim(arg) .eq. '--worker-backend') then + if (iarg + 1 .gt. argc) then + write(*,'(A)') 'missing value after --worker-backend' + call fem_finalize(ierr) + call exit(2) + end if + iarg = iarg + 1 + call getarg(iarg, worker_options%worker_backend) else if (trim(arg) .eq. '--mock-steps') then if (iarg + 1 .gt. argc) then write(*,'(A)') 'missing value after --mock-steps' @@ -140,12 +198,13 @@ program femlite end if iarg = iarg + 1 call getarg(iarg, arg) - read(arg,*,iostat=ios) worker_mock_steps - if (ios .ne. 0 .or. worker_mock_steps .lt. 0) then + read(arg,*,iostat=ios) worker_options%mock_steps + if (ios .ne. 0 .or. worker_options%mock_steps .lt. 0) then write(*,'(A,A)') 'invalid --mock-steps value: ', trim(arg) call fem_finalize(ierr) call exit(2) end if + worker_options%worker_backend = 'mock' else write(*,'(A,A)') 'unknown worker argument: ', trim(arg) call fem_finalize(ierr) @@ -153,16 +212,38 @@ program femlite end if iarg = iarg + 1 end do - if (len_trim(worker_case_arg) .eq. 0) then + if (len_trim(worker_options%case_file) .eq. 0) then write(*,'(A)') 'missing required --case for --cclite-worker' call fem_finalize(ierr) call exit(2) end if - call ccl_worker_run_mock(trim(worker_case_arg), trim(worker_ipc_arg), & - trim(worker_log_arg), trim(worker_output_arg), & - worker_mock_steps, ierr) + solver_id_upper = worker_options%solver_id + call uppercase_arg(solver_id_upper) + if (trim(solver_id_upper) .ne. 'FEM' .and. & + trim(solver_id_upper) .ne. 'FEMLITE') then + write(*,'(A,A)') 'invalid --solver-id value: ', & + trim(worker_options%solver_id) + call fem_finalize(ierr) + call exit(2) + end if + worker_backend_upper = worker_options%worker_backend + call uppercase_arg(worker_backend_upper) + if (trim(worker_backend_upper) .ne. 'MOCK' .and. & + trim(worker_backend_upper) .ne. 'IPC' .and. & + trim(worker_backend_upper) .ne. 'WINDOWS_IPC' .and. & + trim(worker_backend_upper) .ne. 'WINDOWS-SHMEM') then + write(*,'(A,A)') 'invalid --worker-backend value: ', & + trim(worker_options%worker_backend) + call fem_finalize(ierr) + call exit(2) + end if + if (len_trim(worker_options%data_prefix) .eq. 0) then + worker_options%data_prefix = worker_options%ipc_name + end if + call ccl_worker_run(worker_options, ierr) call exit_if_error(ierr) - write(*,'(A)') 'CCLite worker mock completed' + write(*,'(A,A)') 'CCLite worker completed: ', & + trim(worker_options%worker_backend) call fem_finalize(ierr) call exit_if_error(ierr) call exit(0) @@ -647,6 +728,10 @@ program femlite end if end if + if (argc .lt. 1) then + write(*,'(A,I1,A,I1,A,I1)') 'FemLite ', major, '.', minor, '.', patch + end if + call fem_finalize(ierr) call exit_if_error(ierr) diff --git a/src/interface/fem_cclite_ipc.c b/src/interface/fem_cclite_ipc.c index 2091ba9..2e4a319 100644 --- a/src/interface/fem_cclite_ipc.c +++ b/src/interface/fem_cclite_ipc.c @@ -11,6 +11,21 @@ size_t femlite_cclite_command_block_size(void) return sizeof(femlite_cclite_command_block); } +size_t femlite_cclite_data_header_size(void) +{ + return sizeof(femlite_cclite_data_header); +} + +size_t femlite_cclite_facet_record_aor_v1_size(void) +{ + return sizeof(femlite_cclite_facet_record_aor_v1); +} + +size_t femlite_cclite_load_record_aor_v1_size(void) +{ + return sizeof(femlite_cclite_load_record_aor_v1); +} + void femlite_cclite_init_command_block(femlite_cclite_command_block *block) { if (block == NULL) { @@ -20,6 +35,32 @@ void femlite_cclite_init_command_block(femlite_cclite_command_block *block) block->version = FEMLITE_CCL_IPC_VERSION; } +void femlite_cclite_init_data_header(femlite_cclite_data_header *header, + int32_t record_type, + int32_t record_capacity, + int32_t record_stride) +{ + if (header == NULL) { + return; + } + memset(header, 0, sizeof(*header)); + header->magic = FEMLITE_CCL_DATA_MAGIC; + header->version = FEMLITE_CCL_IPC_VERSION; + header->layout = FEMLITE_CCL_DATA_LAYOUT_AOR_V1; + header->record_type = record_type; + header->record_capacity = record_capacity; + header->record_stride = record_stride; +} + +int femlite_cclite_windows_ipc_available(void) +{ +#ifdef _WIN32 + return 1; +#else + return 0; +#endif +} + int femlite_cclite_format_name(const char *prefix, const char *suffix, char *out_name, size_t out_capacity) { @@ -221,6 +262,14 @@ int femlite_cclite_transport_init_mock(femlite_cclite_transport *transport) int femlite_cclite_transport_open_windows(const char *prefix, femlite_cclite_transport *transport) +{ + return femlite_cclite_transport_open_windows_ex(prefix, NULL, transport); +} + +int femlite_cclite_transport_open_windows_ex( + const char *prefix, + const char *command_block_name, + femlite_cclite_transport *transport) { char map_name[256]; char command_event_name[256]; @@ -234,10 +283,17 @@ int femlite_cclite_transport_open_windows(const char *prefix, memset(transport, 0, sizeof(*transport)); transport->backend = FEMLITE_CCL_BACKEND_WINDOWS_IPC; - ierr = femlite_cclite_format_name(prefix, "COMMAND_BLOCK", map_name, - sizeof(map_name)); - if (ierr != FEMLITE_CCL_IPC_SUCCESS) { - return ierr; + if (command_block_name != NULL && command_block_name[0] != '\0') { + if (strlen(command_block_name) + 1 > sizeof(map_name)) { + return FEMLITE_CCL_IPC_ERR_CAPACITY; + } + memcpy(map_name, command_block_name, strlen(command_block_name) + 1); + } else { + ierr = femlite_cclite_format_name(prefix, "COMMAND_BLOCK", map_name, + sizeof(map_name)); + if (ierr != FEMLITE_CCL_IPC_SUCCESS) { + return ierr; + } } ierr = femlite_cclite_format_name(prefix, "COMMAND_EVENT", command_event_name, diff --git a/src/worker/fem_cclite_worker.f90 b/src/worker/fem_cclite_worker.f90 index a539736..618bc0c 100644 --- a/src/worker/fem_cclite_worker.f90 +++ b/src/worker/fem_cclite_worker.f90 @@ -1,4 +1,5 @@ module fem_cclite_worker + use iso_c_binding use fem_precision use fem_error use fem_api @@ -19,6 +20,29 @@ module fem_cclite_worker integer, parameter :: CCL_STATE_DONE = 3 integer, parameter :: CCL_STATE_ERROR = -1 + integer, parameter :: CCL_IPC_SUCCESS = 0 + integer, parameter :: CCL_IPC_ERR_UNSUPPORTED = 1001 + integer, parameter :: CCL_ERROR_MESSAGE_CAPACITY = 128 + integer, parameter :: CCL_DATA_MAGIC = int(Z'46434C44') + integer, parameter :: CCL_DATA_LAYOUT_AOR_V1 = 1 + integer, parameter :: CCL_DATA_RECORD_FACET = 1 + integer, parameter :: CCL_DATA_RECORD_LOAD = 2 + integer, parameter :: CCL_DATA_MAX_FACET_NODES = 8 + + type ccl_worker_options + character(len=256) :: case_file = ' ' + character(len=256) :: ipc_name = 'mock' + character(len=256) :: log_path = ' ' + character(len=256) :: output_dir = ' ' + character(len=256) :: solver_id = 'FEMLite' + character(len=256) :: worker_id = ' ' + character(len=256) :: worker_backend = 'mock' + character(len=256) :: command_block = ' ' + character(len=256) :: data_prefix = ' ' + integer :: timeout_ms = 30000 + integer :: mock_steps = 0 + end type ccl_worker_options + type ccl_worker_block integer :: seq = 0 integer :: ack_seq = 0 @@ -28,8 +52,180 @@ module fem_cclite_worker integer :: iteration_id = 0 integer :: worker_state = CCL_STATE_CREATED integer :: error_code = FEM_SUCCESS + character(len=CCL_ERROR_MESSAGE_CAPACITY) :: error_message = ' ' end type ccl_worker_block + type, bind(C) :: ccl_c_command_block + integer(c_int32_t) :: version + integer(c_int32_t) :: seq + integer(c_int32_t) :: ack_seq + integer(c_int32_t) :: command_id + integer(c_int32_t) :: step_id + integer(c_int32_t) :: substep_id + integer(c_int32_t) :: iteration_id + integer(c_int32_t) :: worker_state + integer(c_int32_t) :: error_code + character(kind=c_char) :: error_message(CCL_ERROR_MESSAGE_CAPACITY) + end type ccl_c_command_block + + type, bind(C) :: ccl_c_map + type(c_ptr) :: handle + type(c_ptr) :: view + integer(c_size_t) :: size + integer(c_int32_t) :: last_native_error + end type ccl_c_map + + type, bind(C) :: ccl_c_event + type(c_ptr) :: handle + integer(c_int32_t) :: last_native_error + end type ccl_c_event + + type, bind(C) :: ccl_c_data_header + integer(c_int32_t) :: magic + integer(c_int32_t) :: version + integer(c_int32_t) :: layout + integer(c_int32_t) :: record_type + integer(c_int32_t) :: record_capacity + integer(c_int32_t) :: record_count + integer(c_int32_t) :: record_stride + integer(c_int32_t) :: status_code + integer(c_int32_t) :: error_code + integer(c_int32_t) :: reserved(7) + character(kind=c_char) :: error_message(CCL_ERROR_MESSAGE_CAPACITY) + end type ccl_c_data_header + + type, bind(C) :: ccl_c_facet_record + integer(c_int32_t) :: facet_id + integer(c_int32_t) :: surface_id + integer(c_int32_t) :: elem_id + integer(c_int32_t) :: face_id + integer(c_int32_t) :: node_count + integer(c_int32_t) :: node_ids(8) + integer(c_int32_t) :: material_id + integer(c_int32_t) :: section_id + integer(c_int32_t) :: body_id + integer(c_int32_t) :: valid_flags + real(c_double) :: x_node(24) + real(c_double) :: v_node(24) + real(c_double) :: normal(3) + real(c_double) :: area + real(c_double) :: shell_thickness + real(c_double) :: mass_per_area + end type ccl_c_facet_record + + type, bind(C) :: ccl_c_load_record + integer(c_int32_t) :: record_id + integer(c_int32_t) :: step_id + integer(c_int32_t) :: node_id + integer(c_int32_t) :: source_id + integer(c_int32_t) :: load_mode + integer(c_int32_t) :: distribution_mode + integer(c_int32_t) :: valid_flags + integer(c_int32_t) :: reserved + real(c_double) :: force(3) + real(c_double) :: moment(3) + end type ccl_c_load_record + + type, bind(C) :: ccl_c_transport + integer(c_int32_t) :: backend + type(ccl_c_map) :: command_map + type(ccl_c_event) :: command_event + type(ccl_c_event) :: done_event + type(ccl_c_command_block) :: mock_command + type(ccl_c_command_block) :: mock_done + integer(c_int32_t) :: has_mock_command + integer(c_int32_t) :: has_mock_done + end type ccl_c_transport + + type ccl_data_blocks + type(ccl_c_map) :: facet_map + type(ccl_c_map) :: load_map + logical :: facet_open = .false. + logical :: load_open = .false. + end type ccl_data_blocks + + interface + function ccl_c_windows_ipc_available() bind(C, & + name='femlite_cclite_windows_ipc_available') result(available) + import :: c_int + integer(c_int) :: available + end function ccl_c_windows_ipc_available + + subroutine ccl_c_init_command_block(block) bind(C, & + name='femlite_cclite_init_command_block') + import :: ccl_c_command_block + type(ccl_c_command_block), intent(out) :: block + end subroutine ccl_c_init_command_block + + function ccl_c_data_header_size() bind(C, & + name='femlite_cclite_data_header_size') result(nbytes) + import :: c_size_t + integer(c_size_t) :: nbytes + end function ccl_c_data_header_size + + function ccl_c_facet_record_size() bind(C, & + name='femlite_cclite_facet_record_aor_v1_size') result(nbytes) + import :: c_size_t + integer(c_size_t) :: nbytes + end function ccl_c_facet_record_size + + function ccl_c_load_record_size() bind(C, & + name='femlite_cclite_load_record_aor_v1_size') result(nbytes) + import :: c_size_t + integer(c_size_t) :: nbytes + end function ccl_c_load_record_size + + function ccl_c_open_shared_memory(name, min_size, map) bind(C, & + name='femlite_cclite_open_shared_memory') result(ierr) + import :: c_char, c_int, c_size_t, ccl_c_map + character(kind=c_char), intent(in) :: name(*) + integer(c_size_t), value :: min_size + type(ccl_c_map), intent(out) :: map + integer(c_int) :: ierr + end function ccl_c_open_shared_memory + + function ccl_c_close_shared_memory(map) bind(C, & + name='femlite_cclite_close_shared_memory') result(ierr) + import :: c_int, ccl_c_map + type(ccl_c_map), intent(inout) :: map + integer(c_int) :: ierr + end function ccl_c_close_shared_memory + + function ccl_c_transport_open_windows_ex(prefix, command_block, & + transport) bind(C, name='femlite_cclite_transport_open_windows_ex') & + result(ierr) + import :: c_char, c_int, ccl_c_transport + character(kind=c_char), intent(in) :: prefix(*) + character(kind=c_char), intent(in) :: command_block(*) + type(ccl_c_transport), intent(out) :: transport + integer(c_int) :: ierr + end function ccl_c_transport_open_windows_ex + + function ccl_c_transport_close(transport) bind(C, & + name='femlite_cclite_transport_close') result(ierr) + import :: c_int, ccl_c_transport + type(ccl_c_transport), intent(inout) :: transport + integer(c_int) :: ierr + end function ccl_c_transport_close + + function ccl_c_transport_receive(transport, timeout_ms, block) bind(C, & + name='femlite_cclite_transport_receive') result(ierr) + import :: c_int, ccl_c_transport, ccl_c_command_block + type(ccl_c_transport), intent(inout) :: transport + integer(c_int), value :: timeout_ms + type(ccl_c_command_block), intent(out) :: block + integer(c_int) :: ierr + end function ccl_c_transport_receive + + function ccl_c_transport_complete(transport, block) bind(C, & + name='femlite_cclite_transport_complete') result(ierr) + import :: c_int, ccl_c_transport, ccl_c_command_block + type(ccl_c_transport), intent(inout) :: transport + type(ccl_c_command_block), intent(in) :: block + integer(c_int) :: ierr + end function ccl_c_transport_complete + end interface + public :: CCL_CMD_INIT public :: CCL_CMD_READ_INPUT public :: CCL_CMD_BUILD_MODEL @@ -43,11 +239,29 @@ module fem_cclite_worker public :: CCL_STATE_RUNNING public :: CCL_STATE_DONE public :: CCL_STATE_ERROR + public :: ccl_worker_options public :: ccl_worker_block + public :: ccl_worker_run public :: ccl_worker_run_mock + public :: ccl_worker_write_capabilities contains + subroutine ccl_worker_run(options, ierr) + type(ccl_worker_options), intent(in) :: options + integer, intent(out) :: ierr + character(len=256) :: backend + + backend = options%worker_backend + call uppercase_text(backend) + if (trim(backend) .eq. 'IPC' .or. trim(backend) .eq. 'WINDOWS_IPC' .or. & + trim(backend) .eq. 'WINDOWS-SHMEM') then + call ccl_worker_run_ipc(options, ierr) + else + call ccl_worker_run_mock_options(options, ierr) + end if + end subroutine ccl_worker_run + subroutine ccl_worker_run_mock(case_file, ipc_name, log_path, output_dir, & step_count, ierr) character(len=*), intent(in) :: case_file @@ -56,57 +270,60 @@ contains character(len=*), intent(in) :: output_dir integer, intent(in) :: step_count integer, intent(out) :: ierr + type(ccl_worker_options) :: options + + options%case_file = case_file + options%ipc_name = ipc_name + options%log_path = log_path + options%output_dir = output_dir + options%worker_backend = 'mock' + options%mock_steps = step_count + call ccl_worker_run_mock_options(options, ierr) + end subroutine ccl_worker_run_mock + + subroutine ccl_worker_run_mock_options(options, ierr) + type(ccl_worker_options), intent(in) :: options + integer, intent(out) :: ierr type(ccl_worker_block) :: block integer :: log_unit - integer :: ios integer :: step integer :: nstep - character(len=256) :: local_log - local_log = log_path - if (len_trim(local_log) .eq. 0) local_log = 'femlite_cclite_worker.log' - nstep = max(0, step_count) + nstep = max(0, options%mock_steps) + call open_worker_log(options, log_unit, ierr) + if (ierr .ne. FEM_SUCCESS) return - log_unit = 79 - open(unit=log_unit, file=trim(local_log), status='replace', & - action='write', iostat=ios) - if (ios .ne. 0) then - call error_set(FEM_ERR_OUTPUT, 'failed to open CCLite worker log', ierr) - return - end if - - call write_worker_header(log_unit, ipc_name, case_file, nstep) - if (len_trim(output_dir) .gt. 0) then - call fem_set_output_directory(trim(output_dir), ierr) + call write_worker_header(log_unit, options, 'mock', nstep) + if (len_trim(options%output_dir) .gt. 0) then + call fem_set_output_directory(trim(options%output_dir), ierr) if (ierr .ne. FEM_SUCCESS) go to 900 end if - call run_command(log_unit, block, CCL_CMD_INIT, 0, case_file, output_dir, ierr) + call run_mock_command(log_unit, block, CCL_CMD_INIT, 0, options, ierr) if (ierr .ne. FEM_SUCCESS) go to 900 - call run_command(log_unit, block, CCL_CMD_READ_INPUT, 0, case_file, & - output_dir, ierr) + call run_mock_command(log_unit, block, CCL_CMD_READ_INPUT, 0, options, & + ierr) if (ierr .ne. FEM_SUCCESS) go to 900 - call run_command(log_unit, block, CCL_CMD_BUILD_MODEL, 0, case_file, & - output_dir, ierr) + call run_mock_command(log_unit, block, CCL_CMD_BUILD_MODEL, 0, options, & + ierr) if (ierr .ne. FEM_SUCCESS) go to 900 - call run_command(log_unit, block, CCL_CMD_EXPORT_IFACE, 0, case_file, & - output_dir, ierr) + call run_mock_command(log_unit, block, CCL_CMD_EXPORT_IFACE, 0, options, & + ierr) if (ierr .ne. FEM_SUCCESS) go to 900 do step = 1, nstep - call run_command(log_unit, block, CCL_CMD_IMPORT_LOADS, step, & - case_file, output_dir, ierr) + call run_mock_command(log_unit, block, CCL_CMD_IMPORT_LOADS, step, & + options, ierr) if (ierr .ne. FEM_SUCCESS) go to 900 - call run_command(log_unit, block, CCL_CMD_ADVANCE, step, case_file, & - output_dir, ierr) + call run_mock_command(log_unit, block, CCL_CMD_ADVANCE, step, options, & + ierr) if (ierr .ne. FEM_SUCCESS) go to 900 end do - call run_command(log_unit, block, CCL_CMD_WRITE_OUTPUT, nstep, case_file, & - output_dir, ierr) + call run_mock_command(log_unit, block, CCL_CMD_WRITE_OUTPUT, nstep, & + options, ierr) if (ierr .ne. FEM_SUCCESS) go to 900 - call run_command(log_unit, block, CCL_CMD_STOP, nstep, case_file, & - output_dir, ierr) + call run_mock_command(log_unit, block, CCL_CMD_STOP, nstep, options, ierr) if (ierr .ne. FEM_SUCCESS) go to 900 close(log_unit) @@ -116,19 +333,122 @@ contains 900 continue block%worker_state = CCL_STATE_ERROR block%error_code = ierr + call set_last_error_message(block) call write_worker_row(log_unit, block) close(log_unit) - end subroutine ccl_worker_run_mock + end subroutine ccl_worker_run_mock_options - subroutine run_command(log_unit, block, command_id, step_id, case_file, & - output_dir, ierr) + subroutine ccl_worker_run_ipc(options, ierr) + type(ccl_worker_options), intent(in) :: options + integer, intent(out) :: ierr + type(ccl_c_transport) :: transport + type(ccl_c_command_block) :: cblock + type(ccl_worker_block) :: block + type(ccl_data_blocks) :: data_blocks + integer :: log_unit + integer(c_int) :: ipc_ierr + character(kind=c_char) :: c_prefix(512) + character(kind=c_char) :: c_command_block(512) + logical :: transport_open + + transport_open = .false. + call open_worker_log(options, log_unit, ierr) + if (ierr .ne. FEM_SUCCESS) return + call write_worker_header(log_unit, options, 'ipc', 0) + + if (len_trim(options%output_dir) .gt. 0) then + call fem_set_output_directory(trim(options%output_dir), ierr) + if (ierr .ne. FEM_SUCCESS) go to 900 + end if + + call to_c_string(options%ipc_name, c_prefix) + call to_c_string(options%command_block, c_command_block) + ipc_ierr = ccl_c_transport_open_windows_ex(c_prefix, c_command_block, & + transport) + if (ipc_ierr .ne. CCL_IPC_SUCCESS) then + call error_set(FEM_ERR_INPUT, 'failed to open CCLite IPC transport', & + ierr) + block%error_code = int(ipc_ierr) + block%worker_state = CCL_STATE_ERROR + block%error_message = 'failed to open CCLite IPC transport' + call write_worker_row(log_unit, block) + go to 900 + end if + transport_open = .true. + + call open_data_blocks(options, data_blocks, block, ierr) + if (ierr .ne. FEM_SUCCESS) then + call write_worker_row(log_unit, block) + go to 900 + end if + + block%worker_state = CCL_STATE_READY + block%error_code = FEM_SUCCESS + block%error_message = 'ready' + call ccl_c_init_command_block(cblock) + call to_c_block(block, cblock) + ipc_ierr = ccl_c_transport_complete(transport, cblock) + call write_worker_row(log_unit, block) + if (ipc_ierr .ne. CCL_IPC_SUCCESS) then + call error_set(FEM_ERR_INPUT, 'failed to signal CCLite worker READY', & + ierr) + go to 900 + end if + + do + ipc_ierr = ccl_c_transport_receive(transport, options%timeout_ms, cblock) + if (ipc_ierr .ne. CCL_IPC_SUCCESS) then + block%worker_state = CCL_STATE_ERROR + block%error_code = int(ipc_ierr) + block%error_message = 'failed to receive CCLite IPC command' + call write_worker_row(log_unit, block) + call error_set(FEM_ERR_INPUT, & + 'failed to receive CCLite IPC command', ierr) + exit + end if + + call from_c_block(cblock, block) + call execute_command(log_unit, block, options, ierr, data_blocks) + call to_c_block(block, cblock) + ipc_ierr = ccl_c_transport_complete(transport, cblock) + if (ipc_ierr .ne. CCL_IPC_SUCCESS) then + call error_set(FEM_ERR_INPUT, 'failed to signal CCLite IPC done', & + ierr) + exit + end if + if (block%command_id .eq. CCL_CMD_STOP) exit + if (ierr .ne. FEM_SUCCESS) exit + end do + +900 continue + call close_data_blocks(data_blocks) + if (transport_open) ipc_ierr = ccl_c_transport_close(transport) + close(log_unit) + end subroutine ccl_worker_run_ipc + + subroutine run_mock_command(log_unit, block, command_id, step_id, options, & + ierr) integer, intent(in) :: log_unit type(ccl_worker_block), intent(inout) :: block integer, intent(in) :: command_id integer, intent(in) :: step_id - character(len=*), intent(in) :: case_file - character(len=*), intent(in) :: output_dir + type(ccl_worker_options), intent(in) :: options integer, intent(out) :: ierr + + block%seq = block%seq + 1 + block%command_id = command_id + block%step_id = step_id + block%substep_id = 0 + block%iteration_id = 0 + call execute_command(log_unit, block, options, ierr) + end subroutine run_mock_command + + subroutine execute_command(log_unit, block, options, ierr, data_blocks) + integer, intent(in) :: log_unit + type(ccl_worker_block), intent(inout) :: block + type(ccl_worker_options), intent(in) :: options + integer, intent(out) :: ierr + type(ccl_data_blocks), intent(inout), optional :: data_blocks integer :: facet_count integer :: max_nodes real(rk) :: time @@ -136,39 +456,43 @@ contains character(len=512) :: load_report character(len=512) :: surface_report - block%seq = block%seq + 1 - block%command_id = command_id - block%step_id = step_id - block%substep_id = 0 - block%iteration_id = 0 block%worker_state = CCL_STATE_RUNNING block%error_code = FEM_SUCCESS + block%error_message = 'running' call write_worker_row(log_unit, block) - select case (command_id) + select case (block%command_id) case (CCL_CMD_INIT) block%worker_state = CCL_STATE_READY ierr = FEM_SUCCESS case (CCL_CMD_READ_INPUT) - call fem_read_inp(trim(case_file), ierr) + call fem_read_inp(trim(options%case_file), ierr) case (CCL_CMD_BUILD_MODEL) call fem_build_model(ierr) if (ierr .eq. FEM_SUCCESS) call fem_compute_lumped_mass(ierr) case (CCL_CMD_EXPORT_IFACE) call fem_get_coupling_surface_count(facet_count, max_nodes, ierr) + if (ierr .eq. FEM_SUCCESS .and. present(data_blocks)) then + call export_facets_to_data(data_blocks, block, ierr) + end if case (CCL_CMD_IMPORT_LOADS) call fem_clear_coupling_loads(ierr) + if (ierr .eq. FEM_SUCCESS .and. present(data_blocks)) then + call import_loads_from_data(data_blocks, block, ierr) + end if case (CCL_CMD_ADVANCE) call fem_advance_explicit(1.0e-12_rk, ierr) case (CCL_CMD_WRITE_OUTPUT) call fem_get_current_time(time, current_step, ierr) if (ierr .eq. FEM_SUCCESS) call fem_write_output(current_step, time, ierr) if (ierr .eq. FEM_SUCCESS) then - call build_output_path(output_dir, 'femlite_cclite_load_report.csv', & - load_report) - call build_output_path(output_dir, 'femlite_cclite_surface_report.csv', & + call build_output_path(options%output_dir, & + 'femlite_cclite_load_report.csv', load_report) + call build_output_path(options%output_dir, & + 'femlite_cclite_surface_report.csv', & surface_report) - call fem_write_cpl_reports(trim(load_report), trim(surface_report), ierr) + call fem_write_cpl_reports(trim(load_report), trim(surface_report), & + ierr) end if case (CCL_CMD_STOP) block%worker_state = CCL_STATE_DONE @@ -180,12 +504,367 @@ contains block%ack_seq = block%seq block%error_code = ierr if (ierr .eq. FEM_SUCCESS) then - if (command_id .ne. CCL_CMD_STOP) block%worker_state = CCL_STATE_READY + block%error_message = 'ok' + if (block%command_id .ne. CCL_CMD_STOP) then + block%worker_state = CCL_STATE_READY + end if else block%worker_state = CCL_STATE_ERROR + call set_last_error_message(block) end if call write_worker_row(log_unit, block) - end subroutine run_command + end subroutine execute_command + + subroutine open_data_blocks(options, blocks, block, ierr) + type(ccl_worker_options), intent(in) :: options + type(ccl_data_blocks), intent(inout) :: blocks + type(ccl_worker_block), intent(inout) :: block + integer, intent(out) :: ierr + + call open_one_data_block(options%data_prefix, 'FEM_TO_CCL_FACET', & + CCL_DATA_RECORD_FACET, ccl_c_facet_record_size(), blocks%facet_map, & + blocks%facet_open, block, ierr) + if (ierr .ne. FEM_SUCCESS) return + + call open_one_data_block(options%data_prefix, 'CCL_TO_FEM_LOAD', & + CCL_DATA_RECORD_LOAD, ccl_c_load_record_size(), blocks%load_map, & + blocks%load_open, block, ierr) + end subroutine open_data_blocks + + subroutine open_one_data_block(prefix, suffix, record_type, min_stride, map, & + is_open, block, ierr) + character(len=*), intent(in) :: prefix + character(len=*), intent(in) :: suffix + integer, intent(in) :: record_type + integer(c_size_t), intent(in) :: min_stride + type(ccl_c_map), intent(out) :: map + logical, intent(out) :: is_open + type(ccl_worker_block), intent(inout) :: block + integer, intent(out) :: ierr + character(len=512) :: block_name + character(kind=c_char) :: c_name(512) + type(ccl_c_data_header), pointer :: header + integer(c_size_t) :: header_size + integer(c_size_t) :: full_size + integer(c_int) :: ipc_ierr + + is_open = .false. + block_name = trim(prefix) // '_' // trim(suffix) + call to_c_string(block_name, c_name) + header_size = ccl_c_data_header_size() + + ipc_ierr = ccl_c_open_shared_memory(c_name, header_size, map) + if (ipc_ierr .ne. CCL_IPC_SUCCESS) then + call set_worker_error(block, int(ipc_ierr), & + 'failed to open CCLite data block', ierr) + return + end if + is_open = .true. + + call c_f_pointer(map%view, header) + call validate_data_header(header, record_type, min_stride, block, ierr) + if (ierr .ne. FEM_SUCCESS) return + + full_size = header_size + int(header%record_capacity, c_size_t) * & + int(header%record_stride, c_size_t) + if (full_size .gt. header_size) then + ipc_ierr = ccl_c_close_shared_memory(map) + is_open = .false. + ipc_ierr = ccl_c_open_shared_memory(c_name, full_size, map) + if (ipc_ierr .ne. CCL_IPC_SUCCESS) then + call set_worker_error(block, int(ipc_ierr), & + 'failed to map full CCLite data block', ierr) + return + end if + is_open = .true. + call c_f_pointer(map%view, header) + call validate_data_header(header, record_type, min_stride, block, ierr) + end if + end subroutine open_one_data_block + + subroutine validate_data_header(header, record_type, min_stride, block, ierr) + type(ccl_c_data_header), pointer, intent(inout) :: header + integer, intent(in) :: record_type + integer(c_size_t), intent(in) :: min_stride + type(ccl_worker_block), intent(inout) :: block + integer, intent(out) :: ierr + + if (.not. associated(header)) then + call set_worker_error(block, FEM_ERR_INPUT, & + 'CCLite data block header is not mapped', ierr) + return + end if + if (int(header%magic) .ne. CCL_DATA_MAGIC .or. & + int(header%layout) .ne. CCL_DATA_LAYOUT_AOR_V1 .or. & + int(header%record_type) .ne. record_type) then + call set_worker_error(block, FEM_ERR_INPUT, & + 'CCLite data block header mismatch', ierr) + return + end if + if (header%record_capacity .lt. 0 .or. header%record_count .lt. 0 .or. & + header%record_count .gt. header%record_capacity) then + call set_worker_error(block, FEM_ERR_INPUT, & + 'CCLite data block record count mismatch', ierr) + return + end if + if (int(header%record_stride, c_size_t) .lt. min_stride) then + call set_worker_error(block, FEM_ERR_INPUT, & + 'CCLite data block record stride mismatch', ierr) + return + end if + ierr = FEM_SUCCESS + end subroutine validate_data_header + + subroutine close_data_blocks(blocks) + type(ccl_data_blocks), intent(inout) :: blocks + integer(c_int) :: ipc_ierr + + if (blocks%load_open) ipc_ierr = ccl_c_close_shared_memory(blocks%load_map) + if (blocks%facet_open) ipc_ierr = ccl_c_close_shared_memory(blocks%facet_map) + blocks%load_open = .false. + blocks%facet_open = .false. + end subroutine close_data_blocks + + subroutine export_facets_to_data(blocks, block, ierr) + type(ccl_data_blocks), intent(inout) :: blocks + type(ccl_worker_block), intent(inout) :: block + integer, intent(out) :: ierr + type(ccl_c_data_header), pointer :: header + type(ccl_c_facet_record), pointer :: records(:) + integer :: nfacet + integer :: max_nodes + integer :: i + integer :: j + integer :: k + integer, allocatable :: facet_id(:) + integer, allocatable :: surface_id(:) + integer, allocatable :: elem_id(:) + integer, allocatable :: face_id(:) + integer, allocatable :: facet_nnode(:) + integer, allocatable :: facet_conn(:,:) + integer, allocatable :: material_id(:) + integer, allocatable :: section_id(:) + integer, allocatable :: valid_flags(:) + real(rk), allocatable :: x(:,:,:) + real(rk), allocatable :: vnod(:,:,:) + real(rk), allocatable :: normal(:,:) + real(rk), allocatable :: area(:) + real(rk), allocatable :: shell_thickness(:) + real(rk), allocatable :: mass_per_area(:) + + call c_f_pointer(blocks%facet_map%view, header) + call validate_data_header(header, CCL_DATA_RECORD_FACET, & + ccl_c_facet_record_size(), block, ierr) + if (ierr .ne. FEM_SUCCESS) return + + call fem_get_coupling_surface_count(nfacet, max_nodes, ierr) + if (ierr .ne. FEM_SUCCESS) return + if (max_nodes .gt. CCL_DATA_MAX_FACET_NODES) then + call set_worker_error(block, FEM_ERR_INPUT, & + 'CCLite facet data block node capacity mismatch', & + ierr) + return + end if + if (nfacet .gt. int(header%record_capacity)) then + call set_worker_error(block, FEM_ERR_INPUT, & + 'CCLite facet data block capacity too small', ierr) + header%error_code = int(block%error_code, c_int32_t) + call to_c_string(block%error_message, header%error_message) + return + end if + if (nfacet .le. 0) then + header%record_count = 0_c_int32_t + header%status_code = 0_c_int32_t + header%error_code = 0_c_int32_t + ierr = FEM_SUCCESS + return + end if + + allocate(facet_id(nfacet), surface_id(nfacet), elem_id(nfacet), & + face_id(nfacet), facet_nnode(nfacet), & + facet_conn(max_nodes,nfacet), material_id(nfacet), & + section_id(nfacet), valid_flags(nfacet), x(NDIM,max_nodes,nfacet), & + vnod(NDIM,max_nodes,nfacet), normal(NDIM,nfacet), area(nfacet), & + shell_thickness(nfacet), mass_per_area(nfacet)) + call fem_get_cpl_surf_facets_ex(nfacet, max_nodes, facet_id, surface_id, & + elem_id, face_id, facet_nnode, facet_conn, x, vnod, normal, area, & + material_id, section_id, valid_flags, shell_thickness, mass_per_area, & + ierr) + if (ierr .ne. FEM_SUCCESS) return + + call c_f_pointer(ptr_offset(blocks%facet_map%view, & + ccl_c_data_header_size()), records, [int(header%record_capacity)]) + do i = 1, nfacet + records(i)%facet_id = int(facet_id(i), c_int32_t) + records(i)%surface_id = int(surface_id(i), c_int32_t) + records(i)%elem_id = int(elem_id(i), c_int32_t) + records(i)%face_id = int(face_id(i), c_int32_t) + records(i)%node_count = int(facet_nnode(i), c_int32_t) + records(i)%node_ids = 0_c_int32_t + records(i)%x_node = 0.0_c_double + records(i)%v_node = 0.0_c_double + do j = 1, facet_nnode(i) + records(i)%node_ids(j) = int(facet_conn(j,i), c_int32_t) + do k = 1, NDIM + records(i)%x_node((j - 1) * 3 + k) = real(x(k,j,i), c_double) + records(i)%v_node((j - 1) * 3 + k) = real(vnod(k,j,i), c_double) + end do + end do + do k = 1, NDIM + records(i)%normal(k) = real(normal(k,i), c_double) + end do + records(i)%area = real(area(i), c_double) + records(i)%material_id = int(material_id(i), c_int32_t) + records(i)%section_id = int(section_id(i), c_int32_t) + records(i)%body_id = 0_c_int32_t + records(i)%valid_flags = int(valid_flags(i), c_int32_t) + records(i)%shell_thickness = real(shell_thickness(i), c_double) + records(i)%mass_per_area = real(mass_per_area(i), c_double) + end do + header%record_count = int(nfacet, c_int32_t) + header%status_code = 0_c_int32_t + header%error_code = 0_c_int32_t + call to_c_string('ok', header%error_message) + ierr = FEM_SUCCESS + end subroutine export_facets_to_data + + subroutine import_loads_from_data(blocks, block, ierr) + type(ccl_data_blocks), intent(inout) :: blocks + type(ccl_worker_block), intent(inout) :: block + integer, intent(out) :: ierr + type(ccl_c_data_header), pointer :: header + type(ccl_c_load_record), pointer :: records(:) + integer :: nload + integer :: i + integer, allocatable :: node_ids(:) + integer, allocatable :: source_ids(:) + integer, allocatable :: load_mode(:) + integer, allocatable :: valid_flags(:) + real(rk), allocatable :: forces(:,:) + + call c_f_pointer(blocks%load_map%view, header) + call validate_data_header(header, CCL_DATA_RECORD_LOAD, & + ccl_c_load_record_size(), block, ierr) + if (ierr .ne. FEM_SUCCESS) return + + nload = int(header%record_count) + if (nload .le. 0) then + header%status_code = 0_c_int32_t + header%error_code = 0_c_int32_t + call to_c_string('ok', header%error_message) + ierr = FEM_SUCCESS + return + end if + + call c_f_pointer(ptr_offset(blocks%load_map%view, ccl_c_data_header_size()), & + records, [int(header%record_capacity)]) + allocate(node_ids(nload), source_ids(nload), load_mode(nload), & + valid_flags(nload), forces(NDIM,nload)) + do i = 1, nload + node_ids(i) = int(records(i)%node_id) + source_ids(i) = int(records(i)%source_id) + load_mode(i) = int(records(i)%load_mode) + valid_flags(i) = int(records(i)%valid_flags) + forces(1,i) = real(records(i)%force(1), rk) + forces(2,i) = real(records(i)%force(2), rk) + forces(3,i) = real(records(i)%force(3), rk) + end do + call fem_apply_coupling_nodal_forces(nload, node_ids, forces, source_ids, & + load_mode, valid_flags, ierr) + if (ierr .eq. FEM_SUCCESS) then + header%status_code = 0_c_int32_t + header%error_code = 0_c_int32_t + call to_c_string('ok', header%error_message) + else + header%status_code = -1_c_int32_t + header%error_code = int(ierr, c_int32_t) + call set_last_error_message(block) + call to_c_string(block%error_message, header%error_message) + end if + end subroutine import_loads_from_data + + subroutine set_worker_error(block, code, message, ierr) + type(ccl_worker_block), intent(inout) :: block + integer, intent(in) :: code + character(len=*), intent(in) :: message + integer, intent(out) :: ierr + + block%worker_state = CCL_STATE_ERROR + block%error_code = code + block%error_message = message(1:min(len_trim(message), & + CCL_ERROR_MESSAGE_CAPACITY)) + call error_set(FEM_ERR_INPUT, trim(message), ierr) + end subroutine set_worker_error + + subroutine ccl_worker_write_capabilities() + integer(c_int) :: available + + available = ccl_c_windows_ipc_available() + write(*,'(A)') 'solver=FEMLite' + write(*,'(A)') 'cclite_worker=yes' + write(*,'(A)') 'worker_mock=yes' + if (available .ne. 0_c_int) then + write(*,'(A)') 'ipc_backend=windows_shmem_named_event' + write(*,'(A)') 'supports_real_ipc=yes' + else + write(*,'(A)') 'ipc_backend=unsupported' + write(*,'(A)') 'supports_real_ipc=no' + end if + write(*,'(A)') 'command_block_version=1' + write(*,'(A)') 'data_layout=AOR_V1' + write(*,'(A)') 'supports_fem_to_ccl_facet=yes' + write(*,'(A)') 'supports_ccl_to_fem_load=yes' + write(*,'(A)') 'max_facet_records=0' + write(*,'(A)') 'max_load_records=0' + end subroutine ccl_worker_write_capabilities + + subroutine open_worker_log(options, log_unit, ierr) + type(ccl_worker_options), intent(in) :: options + integer, intent(out) :: log_unit + integer, intent(out) :: ierr + integer :: ios + character(len=256) :: local_log + + local_log = options%log_path + if (len_trim(local_log) .eq. 0) local_log = 'femlite_cclite_worker.log' + log_unit = 79 + open(unit=log_unit, file=trim(local_log), status='replace', & + action='write', iostat=ios) + if (ios .ne. 0) then + call error_set(FEM_ERR_OUTPUT, 'failed to open CCLite worker log', ierr) + return + end if + ierr = FEM_SUCCESS + end subroutine open_worker_log + + subroutine write_worker_header(log_unit, options, backend, step_count) + integer, intent(in) :: log_unit + type(ccl_worker_options), intent(in) :: options + character(len=*), intent(in) :: backend + integer, intent(in) :: step_count + + write(log_unit,'(A)') 'FemLite CCLite worker' + write(log_unit,'(A,A)') 'backend,', trim(backend) + write(log_unit,'(A,A)') 'solver_id,', trim(options%solver_id) + write(log_unit,'(A,A)') 'worker_id,', trim(options%worker_id) + write(log_unit,'(A,A)') 'ipc_name,', trim(options%ipc_name) + write(log_unit,'(A,A)') 'command_block,', trim(options%command_block) + write(log_unit,'(A,A)') 'data_prefix,', trim(options%data_prefix) + write(log_unit,'(A,I0)') 'timeout_ms,', options%timeout_ms + write(log_unit,'(A,A)') 'case,', trim(options%case_file) + write(log_unit,'(A,I0)') 'mock_steps,', step_count + write(log_unit,'(A)') 'seq,ack_seq,command_id,step_id,substep_id,' // & + 'iteration_id,state,error_code,error_message' + end subroutine write_worker_header + + subroutine write_worker_row(log_unit, block) + integer, intent(in) :: log_unit + type(ccl_worker_block), intent(in) :: block + + write(log_unit,'(8(I0,:,","),A)') block%seq, block%ack_seq, & + block%command_id, block%step_id, block%substep_id, block%iteration_id, & + block%worker_state, block%error_code, ',' // trim(block%error_message) + end subroutine write_worker_row subroutine build_output_path(output_dir, filename, full_path) character(len=*), intent(in) :: output_dir @@ -199,27 +878,88 @@ contains end if end subroutine build_output_path - subroutine write_worker_header(log_unit, ipc_name, case_file, step_count) - integer, intent(in) :: log_unit - character(len=*), intent(in) :: ipc_name - character(len=*), intent(in) :: case_file - integer, intent(in) :: step_count + subroutine set_last_error_message(block) + type(ccl_worker_block), intent(inout) :: block + integer :: code + integer :: ierr_local + character(len=256) :: message - write(log_unit,'(A)') 'FemLite CCLite worker mock' - write(log_unit,'(A,A)') 'ipc_name,', trim(ipc_name) - write(log_unit,'(A,A)') 'case,', trim(case_file) - write(log_unit,'(A,I0)') 'mock_steps,', step_count - write(log_unit,'(A)') & - 'seq,ack_seq,command_id,step_id,substep_id,iteration_id,state,error_code' - end subroutine write_worker_header + call fem_get_last_error(code, message, ierr_local) + if (ierr_local .eq. FEM_SUCCESS .and. len_trim(message) .gt. 0) then + block%error_message = message(1:min(len_trim(message), & + CCL_ERROR_MESSAGE_CAPACITY)) + else + block%error_message = 'FemLite command failed' + end if + end subroutine set_last_error_message - subroutine write_worker_row(log_unit, block) - integer, intent(in) :: log_unit + subroutine to_c_block(block, cblock) type(ccl_worker_block), intent(in) :: block + type(ccl_c_command_block), intent(inout) :: cblock - write(log_unit,'(8(I0,:,","))') block%seq, block%ack_seq, & - block%command_id, block%step_id, block%substep_id, block%iteration_id, & - block%worker_state, block%error_code - end subroutine write_worker_row + cblock%version = 1_c_int32_t + cblock%seq = int(block%seq, c_int32_t) + cblock%ack_seq = int(block%ack_seq, c_int32_t) + cblock%command_id = int(block%command_id, c_int32_t) + cblock%step_id = int(block%step_id, c_int32_t) + cblock%substep_id = int(block%substep_id, c_int32_t) + cblock%iteration_id = int(block%iteration_id, c_int32_t) + cblock%worker_state = int(block%worker_state, c_int32_t) + cblock%error_code = int(block%error_code, c_int32_t) + call to_c_string(block%error_message, cblock%error_message) + end subroutine to_c_block + + subroutine from_c_block(cblock, block) + type(ccl_c_command_block), intent(in) :: cblock + type(ccl_worker_block), intent(inout) :: block + + block%seq = int(cblock%seq) + block%ack_seq = int(cblock%ack_seq) + block%command_id = int(cblock%command_id) + block%step_id = int(cblock%step_id) + block%substep_id = int(cblock%substep_id) + block%iteration_id = int(cblock%iteration_id) + block%worker_state = int(cblock%worker_state) + block%error_code = int(cblock%error_code) + block%error_message = ' ' + end subroutine from_c_block + + function ptr_offset(base, offset) result(out_ptr) + type(c_ptr), intent(in) :: base + integer(c_size_t), intent(in) :: offset + type(c_ptr) :: out_ptr + integer(c_intptr_t) :: address + + address = transfer(base, address) + address = address + int(offset, c_intptr_t) + out_ptr = transfer(address, out_ptr) + end function ptr_offset + + subroutine to_c_string(text, chars) + character(len=*), intent(in) :: text + character(kind=c_char), intent(out) :: chars(:) + integer :: i + integer :: ncopy + + chars = c_null_char + if (size(chars) .le. 0) return + ncopy = min(len_trim(text), size(chars) - 1) + do i = 1, ncopy + chars(i) = text(i:i) + end do + end subroutine to_c_string + + subroutine uppercase_text(text) + character(len=*), intent(inout) :: text + integer :: i + integer :: code + + do i = 1, len_trim(text) + code = iachar(text(i:i)) + if (code .ge. iachar('a') .and. code .le. iachar('z')) then + text(i:i) = achar(code - iachar('a') + iachar('A')) + end if + end do + end subroutine uppercase_text end module fem_cclite_worker diff --git a/tests/cmake/run_cclite_capabilities.cmake b/tests/cmake/run_cclite_capabilities.cmake new file mode 100644 index 0000000..48fc65a --- /dev/null +++ b/tests/cmake/run_cclite_capabilities.cmake @@ -0,0 +1,28 @@ +if(NOT DEFINED FEMLITE_EXE) + message(FATAL_ERROR "FEMLITE_EXE is required") +endif() + +execute_process( + COMMAND "${FEMLITE_EXE}" --cclite-capabilities + RESULT_VARIABLE _rv + OUTPUT_VARIABLE _stdout + ERROR_VARIABLE _stderr +) +if(NOT _rv EQUAL 0) + message(FATAL_ERROR "capabilities failed: ${_stdout}\n${_stderr}") +endif() +if(_stdout MATCHES "FemLite [0-9]") + message(FATAL_ERROR "capabilities output must be key=value only") +endif() +foreach(_key IN ITEMS + "solver=FEMLite" + "cclite_worker=yes" + "worker_mock=yes" + "command_block_version=1" + "data_layout=AOR_V1" + "supports_fem_to_ccl_facet=yes" + "supports_ccl_to_fem_load=yes") + if(NOT _stdout MATCHES "${_key}") + message(FATAL_ERROR "capabilities output missed ${_key}: ${_stdout}") + endif() +endforeach() diff --git a/tests/interface/test_cclite_ipc_adapter.c b/tests/interface/test_cclite_ipc_adapter.c index 449f063..7881b7a 100644 --- a/tests/interface/test_cclite_ipc_adapter.c +++ b/tests/interface/test_cclite_ipc_adapter.c @@ -19,6 +19,7 @@ static void fail(int code, int ierr) static void check_layout(void) { femlite_cclite_command_block block; + femlite_cclite_data_header header; char name[64]; int ierr; @@ -38,6 +39,27 @@ static void check_layout(void) block.ack_seq != 0 || block.error_code != 0) { fail(13, 0); } + if (femlite_cclite_data_header_size() != sizeof(header)) { + fail(17, 0); + } + if (femlite_cclite_facet_record_aor_v1_size() != + sizeof(femlite_cclite_facet_record_aor_v1)) { + fail(18, 0); + } + if (femlite_cclite_load_record_aor_v1_size() != + sizeof(femlite_cclite_load_record_aor_v1)) { + fail(19, 0); + } + femlite_cclite_init_data_header( + &header, FEMLITE_CCL_DATA_RECORD_FEM_TO_CCL_FACET, 12, + (int32_t)sizeof(femlite_cclite_facet_record_aor_v1)); + if (header.magic != FEMLITE_CCL_DATA_MAGIC || + header.layout != FEMLITE_CCL_DATA_LAYOUT_AOR_V1 || + header.record_capacity != 12 || + header.record_stride != + (int32_t)sizeof(femlite_cclite_facet_record_aor_v1)) { + fail(20, 0); + } ierr = femlite_cclite_format_name("Local\\FemLite", "COMMAND", name, sizeof(name)); diff --git a/tests/interface/test_cclite_worker_process.c b/tests/interface/test_cclite_worker_process.c new file mode 100644 index 0000000..82e0fbe --- /dev/null +++ b/tests/interface/test_cclite_worker_process.c @@ -0,0 +1,338 @@ +#include "femlite_cclite_ipc.h" + +#include +#include +#include + +#ifdef _WIN32 +#include +#endif + +static void fail(int code, int ierr) +{ + fprintf(stderr, "test_cclite_worker_process failed at %d: ierr=%d\n", + code, ierr); + exit(1); +} + +#ifdef _WIN32 +static void quote_arg(char *out, size_t capacity, const char *value) +{ + size_t len = strlen(value); + if (len + 3 > capacity) { + fail(10, 0); + } + out[0] = '"'; + memcpy(out + 1, value, len); + out[len + 1] = '"'; + out[len + 2] = '\0'; +} + +static HANDLE create_mapping(const char *name, size_t size, void **view) +{ + HANDLE map = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL, + PAGE_READWRITE, 0, (DWORD)size, name); + if (map == NULL) { + fail(20, (int)GetLastError()); + } + *view = MapViewOfFile(map, FILE_MAP_ALL_ACCESS, 0, 0, size); + if (*view == NULL) { + fail(21, (int)GetLastError()); + } + memset(*view, 0, size); + return map; +} + +static void init_data_block(void *view, int record_type, int capacity, + int stride) +{ + femlite_cclite_data_header *header = + (femlite_cclite_data_header *)view; + femlite_cclite_init_data_header(header, record_type, capacity, stride); +} + +static PROCESS_INFORMATION start_worker(const char *femlite_exe, + const char *prefix, + const char *case_file, + const char *log_file, + const char *output_dir, + int timeout_ms) +{ + PROCESS_INFORMATION pi; + STARTUPINFOA si; + char quoted_exe[1024]; + char quoted_case[1024]; + char quoted_log[1024]; + char quoted_output[1024]; + char command[4096]; + + memset(&pi, 0, sizeof(pi)); + memset(&si, 0, sizeof(si)); + si.cb = sizeof(si); + + quote_arg(quoted_exe, sizeof(quoted_exe), femlite_exe); + quote_arg(quoted_case, sizeof(quoted_case), case_file); + quote_arg(quoted_log, sizeof(quoted_log), log_file); + quote_arg(quoted_output, sizeof(quoted_output), output_dir); + snprintf(command, sizeof(command), + "%s --cclite-worker --worker-backend ipc --case %s " + "--ipc-name %s --data-prefix %s --log %s --output-dir %s " + "--timeout-ms %d", + quoted_exe, quoted_case, prefix, prefix, quoted_log, + quoted_output, timeout_ms); + + if (!CreateProcessA(NULL, command, NULL, NULL, FALSE, + CREATE_NO_WINDOW, NULL, NULL, &si, &pi)) { + fail(30, (int)GetLastError()); + } + return pi; +} + +static void send_command(void *command_view, HANDLE command_event, + HANDLE done_event, int seq, int command_id, + int step_id) +{ + femlite_cclite_command_block *block = + (femlite_cclite_command_block *)command_view; + + if (!ResetEvent(command_event)) { + fail(40 + seq, (int)GetLastError()); + } + if (!ResetEvent(done_event)) { + fail(80 + seq, (int)GetLastError()); + } + femlite_cclite_init_command_block(block); + block->seq = seq; + block->command_id = command_id; + block->step_id = step_id; + if (!SetEvent(command_event)) { + fail(120 + seq, (int)GetLastError()); + } +} + +static void wait_done(void *command_view, HANDLE done_event, int seq, + int expected_state) +{ + femlite_cclite_command_block *block = + (femlite_cclite_command_block *)command_view; + DWORD rc = WaitForSingleObject(done_event, 10000); + if (rc != WAIT_OBJECT_0) { + fail(200 + seq, (int)rc); + } + if (block->ack_seq != seq) { + fail(300 + seq, block->ack_seq); + } + if (expected_state != 0 && block->worker_state != expected_state) { + fail(400 + seq, block->worker_state); + } + if (expected_state != FEMLITE_CCL_STATE_ERROR && block->error_code != 0) { + fail(500 + seq, block->error_code); + } +} + +static int run_command(void *command_view, HANDLE command_event, + HANDLE done_event, int seq, int command_id, + int step_id, int expected_state) +{ + send_command(command_view, command_event, done_event, seq, command_id, + step_id); + wait_done(command_view, done_event, seq, expected_state); + return seq + 1; +} + +static void run_process_loop(const char *femlite_exe, const char *source_dir, + int steps, int timeout_mode, int bad_case_mode) +{ + char prefix[128]; + char command_name[192]; + char command_event_name[192]; + char done_event_name[192]; + char facet_name[192]; + char load_name[192]; + char case_file[1024]; + char log_file[1024]; + char output_dir[1024]; + HANDLE command_map; + HANDLE facet_map; + HANDLE load_map; + HANDLE command_event; + HANDLE done_event; + void *command_view; + void *facet_view; + void *load_view; + PROCESS_INFORMATION pi; + DWORD rc; + DWORD exit_code; + int seq = 1; + int step; + size_t facet_size; + size_t load_size; + femlite_cclite_data_header *facet_header; + + snprintf(prefix, sizeof(prefix), "Local\\FemLiteWorkerProc_%lu_%d", + (unsigned long)GetCurrentProcessId(), steps); + if (femlite_cclite_format_name(prefix, "COMMAND_BLOCK", command_name, + sizeof(command_name)) != 0) { + fail(1000, 0); + } + if (femlite_cclite_format_name(prefix, "COMMAND_EVENT", + command_event_name, + sizeof(command_event_name)) != 0) { + fail(1001, 0); + } + if (femlite_cclite_format_name(prefix, "DONE_EVENT", done_event_name, + sizeof(done_event_name)) != 0) { + fail(1002, 0); + } + if (femlite_cclite_format_name(prefix, "FEM_TO_CCL_FACET", facet_name, + sizeof(facet_name)) != 0) { + fail(1003, 0); + } + if (femlite_cclite_format_name(prefix, "CCL_TO_FEM_LOAD", load_name, + sizeof(load_name)) != 0) { + fail(1004, 0); + } + + command_map = create_mapping(command_name, + sizeof(femlite_cclite_command_block), + &command_view); + facet_size = sizeof(femlite_cclite_data_header) + + 64 * sizeof(femlite_cclite_facet_record_aor_v1); + load_size = sizeof(femlite_cclite_data_header) + + 8 * sizeof(femlite_cclite_load_record_aor_v1); + facet_map = create_mapping(facet_name, facet_size, &facet_view); + load_map = create_mapping(load_name, load_size, &load_view); + init_data_block(facet_view, FEMLITE_CCL_DATA_RECORD_FEM_TO_CCL_FACET, + 64, (int)sizeof(femlite_cclite_facet_record_aor_v1)); + init_data_block(load_view, FEMLITE_CCL_DATA_RECORD_CCL_TO_FEM_LOAD, + 8, (int)sizeof(femlite_cclite_load_record_aor_v1)); + + command_event = CreateEventA(NULL, FALSE, FALSE, command_event_name); + done_event = CreateEventA(NULL, TRUE, FALSE, done_event_name); + if (command_event == NULL || done_event == NULL) { + fail(1005, (int)GetLastError()); + } + + if (bad_case_mode) { + snprintf(case_file, sizeof(case_file), "%s\\tests\\data\\missing.inp", + source_dir); + } else { + snprintf(case_file, sizeof(case_file), + "%s\\examples\\c3d4_one_element.inp", source_dir); + } + snprintf(log_file, sizeof(log_file), "%s\\build-codex-gcc\\worker_proc_%d.log", + source_dir, steps); + snprintf(output_dir, sizeof(output_dir), + "%s\\build-codex-gcc\\worker_proc_results_%d", + source_dir, steps); + pi = start_worker(femlite_exe, prefix, case_file, log_file, + output_dir, timeout_mode ? 100 : 10000); + + wait_done(command_view, done_event, 0, FEMLITE_CCL_STATE_READY); + if (timeout_mode) { + rc = WaitForSingleObject(pi.hProcess, 10000); + if (rc != WAIT_OBJECT_0) { + fail(1100, (int)rc); + } + if (!GetExitCodeProcess(pi.hProcess, &exit_code)) { + fail(1101, (int)GetLastError()); + } + if (exit_code == 0) { + fail(1102, (int)exit_code); + } + goto cleanup; + } + if (bad_case_mode) { + seq = run_command(command_view, command_event, done_event, seq, + FEMLITE_CCL_CMD_INIT, 0, FEMLITE_CCL_STATE_READY); + seq = run_command(command_view, command_event, done_event, seq, + FEMLITE_CCL_CMD_READ_INPUT, 0, + FEMLITE_CCL_STATE_ERROR); + rc = WaitForSingleObject(pi.hProcess, 10000); + if (rc != WAIT_OBJECT_0) { + fail(1150, (int)rc); + } + if (!GetExitCodeProcess(pi.hProcess, &exit_code)) { + fail(1151, (int)GetLastError()); + } + if (exit_code == 0) { + fail(1152, (int)exit_code); + } + goto cleanup; + } + + seq = run_command(command_view, command_event, done_event, seq, + FEMLITE_CCL_CMD_INIT, 0, FEMLITE_CCL_STATE_READY); + seq = run_command(command_view, command_event, done_event, seq, + FEMLITE_CCL_CMD_READ_INPUT, 0, FEMLITE_CCL_STATE_READY); + seq = run_command(command_view, command_event, done_event, seq, + FEMLITE_CCL_CMD_BUILD_MODEL, 0, FEMLITE_CCL_STATE_READY); + seq = run_command(command_view, command_event, done_event, seq, + FEMLITE_CCL_CMD_EXPORT_IFACE, 0, + FEMLITE_CCL_STATE_READY); + + facet_header = (femlite_cclite_data_header *)facet_view; + if (facet_header->record_count <= 0) { + fail(1200, facet_header->record_count); + } + + for (step = 1; step <= steps; ++step) { + ((femlite_cclite_data_header *)load_view)->record_count = 0; + seq = run_command(command_view, command_event, done_event, seq, + FEMLITE_CCL_CMD_IMPORT_LOADS, step, + FEMLITE_CCL_STATE_READY); + seq = run_command(command_view, command_event, done_event, seq, + FEMLITE_CCL_CMD_ADVANCE, step, + FEMLITE_CCL_STATE_READY); + } + + seq = run_command(command_view, command_event, done_event, seq, + FEMLITE_CCL_CMD_WRITE_OUTPUT, steps, + FEMLITE_CCL_STATE_READY); + seq = run_command(command_view, command_event, done_event, seq, + FEMLITE_CCL_CMD_STOP, steps, FEMLITE_CCL_STATE_DONE); + rc = WaitForSingleObject(pi.hProcess, 10000); + if (rc != WAIT_OBJECT_0) { + fail(1300, (int)rc); + } + if (!GetExitCodeProcess(pi.hProcess, &exit_code) || exit_code != 0) { + fail(1301, (int)exit_code); + } + +cleanup: + CloseHandle(pi.hThread); + CloseHandle(pi.hProcess); + CloseHandle(done_event); + CloseHandle(command_event); + UnmapViewOfFile(load_view); + UnmapViewOfFile(facet_view); + UnmapViewOfFile(command_view); + CloseHandle(load_map); + CloseHandle(facet_map); + CloseHandle(command_map); +} +#endif + +int main(int argc, char **argv) +{ +#ifdef _WIN32 + int steps; + int timeout_mode = 0; + int bad_case_mode = 0; + if (argc < 4) { + fail(1, argc); + } + steps = atoi(argv[3]); + if (argc > 4 && strcmp(argv[4], "timeout") == 0) { + timeout_mode = 1; + } + if (argc > 4 && strcmp(argv[4], "badcase") == 0) { + bad_case_mode = 1; + } + run_process_loop(argv[1], argv[2], steps, timeout_mode, bad_case_mode); +#else + (void)argc; + (void)argv; +#endif + return 0; +} diff --git a/todo.md b/todo.md index 6dd539e..77021f2 100644 --- a/todo.md +++ b/todo.md @@ -1,82 +1,86 @@ # FemLite TODO -文档状态:根据 `docs/12_cclite_integration_suggestions.md` 重写,并随 0.6.x CCLite coupling 闭环更新。 +文档状态:根据 `docs/12_cclite_integration_suggestions.md` 重写。当前待办面向 0.6.5,目标是完成真实 IPC worker 接入闭环。 -## 开发原则 +## 开发边界 +- [x] 保留现有 worker mock,不把 mock 结果描述为真实 IPC worker。 - [x] 保持 FemLite 独立求解器身份,不把 CCLite/SPHLite 算法核心写入 FemLite。 -- [x] 先固化中立 coupling API,再做 worker/service,再接 Windows IPC。 -- [x] 每个待办都有 smoke、单元测试或文档验收。 -- [x] 旧 `sph` 命名接口保留兼容,不在本轮直接删除。 +- [x] 本轮只做数据边界、worker 通信、自测和诊断,不做真实 SPH-FEM 接触物理验收。 +- [x] 每个开发阶段完成后补充对应 smoke、单元测试或文档验收。 -## 阶段 A:中立 Coupling API 固化 +## 阶段 A:Worker CLI 与能力查询 -- [x] 盘点现有 boundary facet Fortran API、C ABI 和测试覆盖。 -- [x] 盘点现有 sph/facet load Fortran API、C ABI 和测试覆盖。 -- [x] 设计中立 coupling surface 查询接口名称、参数和错误返回规则。 -- [x] 增加 Fortran 层 coupling surface count/facets wrapper,并保持旧接口兼容。 -- [x] 增加 C ABI coupling surface count/facets wrapper,并补充头文件声明。 -- [x] 增加 coupling nodal force 导入接口,明确数组展开和容量规则。 -- [x] 增加 Fortran 层 coupling nodal force wrapper,并接入现有外部载荷路径。 -- [x] 增加 C ABI coupling nodal force wrapper,并补充头文件声明。 -- [x] 增加 coupling load 总力、总力矩、接受计数和拒绝计数诊断。 -- [x] 补充 C API smoke,覆盖 surface/facet 查询、空载荷、节点力和错误边界。 -- [x] 更新 `docs/05_interface_control_document.md` 和 CCLite 建议文档。 +- [x] 盘点现有 `--cclite-worker` 参数解析、默认值、错误返回和测试覆盖。 +- [x] 增加 `--solver-id`、`--timeout-ms`、`--worker-id` 参数,并保持旧参数兼容。 +- [x] 增加 `--command-block`、`--data-prefix`、`--worker-backend` 参数,并明确 mock/ipc 模式选择规则。 +- [x] 校验 `--solver-id` 初期只接受 `FEM` 或 `FEMLite`,错误时输出稳定错误码。 +- [x] 新增 `--cclite-capabilities` CLI,输出稳定 `key=value` 文本。 +- [x] 为能力查询补充测试,覆盖 mock、Windows IPC 支持状态和非 Windows unsupported 状态。 -## 阶段 B:Worker Mock 协议闭环 +## 阶段 B:Worker 命令执行器解耦 -- [x] 设计 worker command/state 枚举,覆盖 INIT 到 STOP。 -- [x] 增加 worker command block,包含 seq、ack、step、state 和 error 字段。 -- [x] 增加 `--cclite-worker` CLI 入口,不影响原 CLI 行为。 -- [x] 增加 READ_INPUT、BUILD_MODEL、EXPORT_INTERFACE、IMPORT_LOADS、ADVANCE、WRITE_OUTPUT 和 STOP 命令处理。 -- [x] 增加 worker CSV 日志,记录启动参数、命令状态和错误码。 -- [x] 补充 worker 启动、READY、seq/ack、100 step 空耦合、STOP 和错误路径 smoke。 -- [x] 更新用户文档,说明 worker mock 仍非真实 IPC。 +- [x] 盘点现有 mock worker 命令状态机和日志字段,找出与 mock backend 绑定的逻辑。 +- [x] 抽出 backend 无关的 worker 命令执行器,覆盖 `INIT` 到 `STOP` 命令。 +- [x] 让 mock worker 改用统一命令执行器,确保原有 100 step 空耦合测试不退化。 +- [x] 统一 `seq`、`ack_seq`、`worker_state`、`error_code` 和短错误消息的写回规则。 +- [x] 增加命令执行器单元测试,覆盖正常命令、未知命令、错误输入和 STOP 退出。 -## 阶段 C:Windows IPC Adapter +## 阶段 C:真实 IPC Worker 主循环 -- [x] 设计 Windows command block 二进制布局,与 CCLite 字段命名对齐。 -- [x] 增加 Windows shared memory open/close wrapper,只 open 不 create。 -- [x] 增加 Windows named event open/wait/signal/close wrapper,只 wait/signal 不 reset。 -- [x] 增加 IPC 超时参数和稳定错误码。 -- [x] 抽象 worker transport 为 mock 和 Windows IPC 两个后端。 -- [x] 接入 COMMAND_EVENT wait、command block 读取、ack/state/error 写回和 DONE_EVENT signal。 -- [x] 补充 IPC INIT/STOP、100 step 空耦合、超时和错误路径 smoke。 -- [x] 更新文档,明确 event reset 责任属于 CCLite。 +- [x] 将真实 IPC worker 接入现有 `femlite_cclite_transport` facade,不新增第二套 IPC 封装。 +- [x] 启动真实 IPC worker 时打开 command block、command event 和 done event。 +- [x] 在真实 IPC worker 启动后进入 READY 状态,并写回初始 ack/state/error 字段。 +- [x] 实现真实 IPC worker 的 wait command、执行命令、写回状态、signal done 主循环。 +- [x] 确认 FemLite 只 wait/signal named event,不 reset 由 CCLite 创建的 event。 +- [x] 为 IPC attach、READY、STOP、timeout 和 open 失败路径补充测试。 -## 阶段 D:Surface/Facet 完整导出 +## 阶段 D:AOR_V1 Data Block -- [x] 梳理 boundary facet 字段来源,确认 facet_id、elem_id、face_id、node_ids。 -- [x] 增加 surface_id 导出占位规则,未指定 surface 时返回 0 并写 warning。 -- [x] 增加 material_id、section_id、valid_flags、shell_thickness 和 mass_per_area 导出字段。 -- [x] 增加当前构型 normal 归一化检查和退化 facet invalid flag。 -- [x] 增加退化三角形、退化四边形、实体面厚度为 0、壳厚度和面密度测试。 -- [x] 支持 `*SURFACE, NAME=..., TYPE=ELEMENT` 的 coupling 导出过滤。 -- [x] 增加单三角形、单四边形和壳厚度导出验收 deck。 -- [x] 更新接口文档和 CCLite 联合改造建议文档。 +- [x] 设计 `AOR_V1` data block header,包含 magic、version、capacity、record count 和错误字段。 +- [x] 设计 `FEM_TO_CCL_FACET` 最小 facet record,覆盖节点、位置、法向、面积和材料/截面字段。 +- [x] 设计 `CCL_TO_FEM_LOAD` 最小 nodal force record,覆盖节点力、source、load mode 和 valid flags。 +- [x] 实现 data block 打开、版本检查、容量检查和错误返回,不由 FemLite 创建 data block。 +- [x] 实现空 facet、空 load 的读写闭环,作为真实 IPC worker 最小验收路径。 +- [x] 将 nodal force records 映射到现有 coupling 节点力导入接口。 +- [x] 将 facet records 映射到现有 surface/facet 导出接口,暂以现有字段为准。 +- [x] 为 data block header、容量不足、版本不匹配和空记录路径补充测试。 -## 阶段 E:外部载荷导入与诊断 +## 阶段 E:诊断与日志 -- [x] 设计独立 coupling external load 缓存,不直接暴露全局力数组。 -- [x] 增加每个 CCLite step 前清零 external load 缓存的生命周期入口。 -- [x] 将 coupling nodal force 叠加到显式动力外力路径。 -- [x] 将 coupling nodal force 叠加到静力/隐式 RHS 路径。 -- [x] 增加 source_id、load_mode 和 valid_flags 的输入校验。 -- [x] 增加本步 coupling 总力统计。 -- [x] 增加本步 coupling 总力矩统计。 -- [x] 增加按 source 汇总 coupling 载荷的诊断接口。 -- [x] 增加 `femlite_cclite_load_report.csv` 输出。 -- [x] 增加 `femlite_cclite_surface_report.csv` 输出。 -- [x] 增加节点力导入后显式单步响应测试。 -- [x] 增加节点力导入后静力 RHS 响应测试。 -- [x] 增加 force balance CSV 对账测试。 -- [x] 增加 VTU/PVD 输出与 worker 诊断一致性测试。 -- [x] 更新示例 README,说明 CCLite 载荷导入仍是基础节点力闭环。 +- [x] 扩展 worker log header,记录 backend、solver_id、worker_id、ipc_name 和 timeout。 +- [x] 扩展 worker log header,记录 command_block、data_prefix 和实际 data block 名称。 +- [x] 扩展每条命令日志,记录 command_id、step_id、substep_id、iteration_id 和 ack_seq。 +- [x] 扩展每条命令日志,记录 worker_state、error_code 和短错误消息。 +- [x] 在 `WRITE_OUTPUT` 或每步结束时同步输出 surface/load 诊断统计。 +- [x] 保持 `femlite_cclite_worker.log`、`femlite_cclite_surface_report.csv`、`femlite_cclite_load_report.csv` 文件名稳定。 +- [x] 为日志字段、错误消息和诊断 CSV 输出补充回归测试。 -## 暂不纳入本轮 +## 阶段 F:Process-Level 自测与联调准备 +- [x] 增加本地 IPC self-test helper,用于创建 shared memory 和 named event 测试对象。 +- [x] 增加 process-level worker 自测,覆盖启动、attach、READY、空 facet、空 load 和 STOP。 +- [x] 增加 1 step 空耦合进程级 smoke,验证 CCLite mock 驱动真实 FemLite worker。 +- [x] 增加 100 step 空耦合进程级 smoke,验证 seq/ack、日志和稳定退出。 +- [x] 增加异常输入和 timeout 进程级 smoke,验证可控错误和退出码。 +- [x] 将 process-level 自测纳入常规回归入口,必要时按平台跳过 Windows-only 测试。 + +## 阶段 G:文档与版本边界 + +- [x] 更新接口控制文档,说明 worker mock、IPC adapter、real IPC worker 的边界。 +- [x] 更新 CCLite 联合改造文档,记录 0.6.5 已完成项和仍暂缓项。 +- [x] 更新用户文档,给出 `--cclite-worker` 和 `--cclite-capabilities` 示例。 +- [x] 更新开发路线图,将 0.6.6/0.6.7 的 surface/body id、facet pressure 和 force balance 边界保持清晰。 +- [x] 更新发布检查清单,加入真实 IPC worker 自测、能力查询和日志字段验收。 + +## 暂缓到后续版本 + +- [ ] DEFERRED:稳定 surface id 显式映射和真实 `body_id` 映射。 +- [ ] DEFERRED:facet pressure 中立 data block 导入和完整物理验收。 +- [ ] DEFERRED:moment 外部载荷导入。 +- [ ] DEFERRED:kinematic boundary 外部约束导入。 - [ ] DEFERRED:真实 SPH-FEM penalty contact 物理验收。 - [ ] DEFERRED:FSI 工程算例。 -- [ ] DEFERRED:tie/release 联合接触。 +- [ ] DEFERRED:tied/release 联合接触。 - [ ] DEFERRED:强耦合 rollback 和预测状态接口。 - [ ] DEFERRED:删除旧 `sph` 命名接口。