diff --git a/CMakeLists.txt b/CMakeLists.txt index b20dc20..26588ee 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,6 +1,6 @@ cmake_minimum_required(VERSION 3.20) -project(CCLite VERSION 0.1.9 LANGUAGES C Fortran) +project(CCLite VERSION 0.1.10 LANGUAGES C Fortran) set(CMAKE_Fortran_STANDARD 2018) set(CMAKE_Fortran_STANDARD_REQUIRED ON) diff --git a/Python/checkers/audit_real_workers.py b/Python/checkers/audit_real_workers.py index f85d4dc..6153c81 100644 --- a/Python/checkers/audit_real_workers.py +++ b/Python/checkers/audit_real_workers.py @@ -6,9 +6,9 @@ import subprocess from pathlib import Path -def run_command(command: list[str]) -> dict: +def run_command(command: list[str], timeout: float = 10.0) -> dict: try: - completed = subprocess.run(command, text=True, capture_output=True, timeout=10.0) + completed = subprocess.run(command, text=True, capture_output=True, timeout=timeout) except subprocess.TimeoutExpired as exc: return { "command": command, @@ -27,10 +27,51 @@ def run_command(command: list[str]) -> dict: } -def run_standard_worker_probe(exe: Path, solver_id: str, case_file: Path) -> dict: - result = run_command([ +def parse_key_value_output(text: str) -> dict[str, str]: + values: dict[str, str] = {} + for raw_line in text.splitlines(): + line = raw_line.strip() + if not line or line.startswith("["): + continue + if "=" not in line: + continue + key, value = line.split("=", 1) + values[key.strip()] = value.strip() + return values + + +def is_yes(values: dict[str, str], key: str) -> bool: + return values.get(key, "").strip().lower() in {"yes", "true", "1", "on"} + + +def run_capabilities_probe(exe: Path) -> dict: + result = run_command([str(exe), "--cclite-capabilities"]) + output = (result.get("stdout") or "") + "\n" + (result.get("stderr") or "") + capabilities = parse_key_value_output(output) + result["capabilities"] = capabilities + if result["exit_code"] == 0 and capabilities.get("cclite_worker", "").lower() == "yes": + result["status"] = "CAPABILITIES_AVAILABLE" + elif "unknown" in output.lower() and "capabilities" in output.lower(): + result["status"] = "MISSING_CAPABILITIES_CLI" + else: + result["status"] = "CAPABILITIES_FAILED" + result["supports_real_ipc"] = is_yes(capabilities, "supports_real_ipc") + return result + + +def run_standard_worker_probe( + exe: Path, + solver_id: str, + case_file: Path, + extra_args: list[str] | None = None, +) -> dict: + command = [ str(exe), "--cclite-worker", + ] + if extra_args: + command.extend(extra_args) + command.extend([ "--solver-id", solver_id, "--case", @@ -40,12 +81,20 @@ def run_standard_worker_probe(exe: Path, solver_id: str, case_file: Path) -> dic "--timeout-ms", "100", ]) + result = run_command(command) output = (result.get("stdout") or "") + "\n" + (result.get("stderr") or "") - recognized = "--solver-id" not in output and "unknown argument" not in output + output_lower = output.lower() + recognized = "--solver-id" not in output and "unknown argument" not in output_lower and "unknown worker argument" not in output_lower unsupported = "not implemented" in output.lower() or "unsupported" in output.lower() - result["status"] = classify_standard_probe(recognized, unsupported, result["exit_code"]) + attach_attempted = ( + "ipc attach failed" in output_lower + or "failed to open cclite ipc transport" in output_lower + or ("failed to open" in output_lower and "ipc" in output_lower) + ) + result["status"] = classify_standard_probe(recognized, unsupported, attach_attempted, result["exit_code"]) result["recognized_worker_cli"] = recognized - result["ipc_implemented"] = recognized and result["exit_code"] == 0 and not unsupported + result["real_ipc_attach_attempted"] = recognized and attach_attempted + result["ready_without_external_resources"] = recognized and result["exit_code"] == 0 and not unsupported return result @@ -67,9 +116,12 @@ def run_femlite_mock_probe(exe: Path, case_file: Path, report_path: Path) -> dic "1", ]) output = (result.get("stdout") or "") + "\n" + (result.get("stderr") or "") - if result["exit_code"] == 0 and "worker mock completed" in output.lower(): + output_lower = output.lower() + if result["exit_code"] == 0 and ( + "worker mock completed" in output_lower or "worker completed: mock" in output_lower + ): result["status"] = "WORKER_MOCK_AVAILABLE" - elif "unknown worker argument" in output.lower() or "unknown argument" in output.lower(): + elif "unknown worker argument" in output_lower or "unknown argument" in output_lower: result["status"] = "MISSING_WORKER_MOCK_CLI" else: result["status"] = "WORKER_MOCK_FAILED" @@ -78,9 +130,16 @@ def run_femlite_mock_probe(exe: Path, case_file: Path, report_path: Path) -> dic return result -def classify_standard_probe(recognized: bool, unsupported: bool, exit_code: int | None) -> str: +def classify_standard_probe( + recognized: bool, + unsupported: bool, + attach_attempted: bool, + exit_code: int | None, +) -> str: if recognized and unsupported: return "CONTROLLED_UNSUPPORTED" + if recognized and attach_attempted: + return "IPC_ATTACH_ATTEMPTED" if recognized and exit_code == 0: return "READY_FOR_REAL_IPC" if not recognized: @@ -88,6 +147,60 @@ def classify_standard_probe(recognized: bool, unsupported: bool, exit_code: int return "FAILED" +def build_protocol_alignment(fem_exe: Path) -> dict: + fem_include = fem_exe.parent.parent / "include" / "femlite_cclite_ipc.h" + fem_native_header = False + if fem_include.exists(): + text = fem_include.read_text(encoding="utf-8", errors="ignore") + fem_native_header = ( + "femlite_cclite_command_block" in text + and "femlite_cclite_data_header" in text + ) + + return { + "status": "CCLITE_PROTOCOL_ADAPTER_REQUIRED", + "cclite_current_protocol": { + "command_block": "CCLite generic command block v1", + "data_header": "CCLite generic data block header v0.1", + "control_names": [ + "_CCL_COMMAND_", + "_EVENT_COMMAND_", + "_EVENT_ACK_", + ], + "data_names": [ + "_SPH_TO_CCL_PARTICLE", + "_FEM_TO_CCL_FACET", + "_CCL_TO_SPH_FORCE", + "_CCL_TO_FEM_LOAD", + ], + }, + "sphlite_observed_protocol": { + "default_control_names": [ + ".command", + ".command_event", + ".done_event", + ], + "supports_name_overrides": ["--command-block", "--data-prefix"], + "note": "SPHLite reports real IPC support, but true external CCLite process interop still requires a CCLite-side protocol/name adapter test.", + }, + "femlite_observed_protocol": { + "native_header_detected": fem_native_header, + "header": str(fem_include), + "requires_worker_backend": "--worker-backend ipc", + "control_names": [ + "_COMMAND_BLOCK", + "_COMMAND_EVENT", + "_DONE_EVENT", + ], + "data_names": [ + "_FEM_TO_CCL_FACET", + "_CCL_TO_FEM_LOAD", + ], + "note": "The current FEMLite package uses a native compact command block/data header that is not the same binary layout as CCLite 0.1.x generic blocks.", + }, + } + + def main() -> int: parser = argparse.ArgumentParser() parser.add_argument("--sph-exe", required=True) @@ -99,14 +212,34 @@ def main() -> int: case_dir = Path(args.case_dir) report_path = Path(args.report) - sph_standard = run_standard_worker_probe(Path(args.sph_exe), "SPH", case_dir / "mock_sph.inp") - fem_standard = run_standard_worker_probe(Path(args.fem_exe), "FEM", Path(args.fem_case)) - fem_mock = run_femlite_mock_probe(Path(args.fem_exe), Path(args.fem_case), report_path) + sph_exe = Path(args.sph_exe) + fem_exe = Path(args.fem_exe) + sph_capabilities = run_capabilities_probe(sph_exe) + fem_capabilities = run_capabilities_probe(fem_exe) + sph_standard = run_standard_worker_probe(sph_exe, "SPH", case_dir / "mock_sph.inp") + fem_standard = run_standard_worker_probe(fem_exe, "FEM", Path(args.fem_case)) + fem_explicit_ipc = run_standard_worker_probe( + fem_exe, + "FEM", + Path(args.fem_case), + ["--worker-backend", "ipc", "--data-prefix", "CCLITE_REAL_WORKER_AUDIT"], + ) + fem_mock = run_femlite_mock_probe(fem_exe, Path(args.fem_case), report_path) + protocol_alignment = build_protocol_alignment(fem_exe) - status = "PARTIAL_EXTERNAL_WORKER_SUPPORT" - if sph_standard["ipc_implemented"] and fem_standard["ipc_implemented"]: - status = "READY_FOR_REAL_IPC" - elif fem_mock["status"] != "WORKER_MOCK_AVAILABLE": + both_report_real_ipc = sph_capabilities["supports_real_ipc"] and fem_capabilities["supports_real_ipc"] + both_attach_attempted = ( + sph_standard["real_ipc_attach_attempted"] + and (fem_standard["real_ipc_attach_attempted"] or fem_explicit_ipc["real_ipc_attach_attempted"]) + ) + + if both_report_real_ipc and both_attach_attempted: + status = "EXTERNAL_WORKERS_READY_CCLITE_PROTOCOL_ADAPTER_REQUIRED" + elif both_report_real_ipc: + status = "EXTERNAL_WORKERS_REPORT_REAL_IPC" + elif fem_mock["status"] == "WORKER_MOCK_AVAILABLE": + status = "PARTIAL_EXTERNAL_WORKER_SUPPORT" + else: status = "CONTROLLED_GAP" report = { @@ -118,14 +251,19 @@ def main() -> int: "--ipc-name ", "--timeout-ms ", ], + "sphlite_capabilities": sph_capabilities, + "femlite_capabilities": fem_capabilities, "sphlite_standard_ipc": sph_standard, "femlite_standard_ipc": fem_standard, + "femlite_explicit_ipc_backend": fem_explicit_ipc, "femlite_worker_mock": fem_mock, + "protocol_alignment": protocol_alignment, "conclusion": [ - "SPHLite 0.8.2 recognizes worker mode but reports real IPC as not implemented.", - "FEMLite 0.6.4 provides a self-running CCLite worker mock.", - "FEMLite 0.6.4 does not yet accept the full CCLite standard IPC worker argument set.", - "CCLite 0.1.9 keeps mock-worker IPC integration as the executable acceptance path.", + "The current SPHLite package reports CCLite worker and Windows shared memory/named event support.", + "The current FEMLite package reports CCLite worker, worker mock, and Windows shared memory/named event support.", + "Both workers now attempt real IPC attach when launched without pre-created CCLite resources.", + "CCLite 0.1.10 still treats true external process interop as requiring a CCLite-side protocol/name adapter, because the published FEMLite IPC structures and names differ from CCLite 0.1.x generic blocks.", + "Mock-worker IPC integration remains the executable acceptance path until the adapter-level process tests pass.", ], } diff --git a/docs/0.1.x_release_notes.md b/docs/0.1.x_release_notes.md index 820e1d2..41d5a59 100644 --- a/docs/0.1.x_release_notes.md +++ b/docs/0.1.x_release_notes.md @@ -19,23 +19,24 @@ ## 3. 验证结果 -本地 0.1.8 验证项: +本地 0.1.10 验证项: 1. 全量 CTest 通过; 2. `V010_EMPTY_COUPLING` checker 输出 `PASS`; 3. UTF-8 without BOM 检查通过; 4. 干净构建目录重建和测试通过; -5. 真实 worker audit 输出 SPHLite 标准 IPC 状态、FEMLite 标准 IPC 状态和 FEMLite worker mock 状态。 +5. 真实 worker audit 输出 SPHLite/FEMLite 能力查询、标准 IPC attach 探测、FEMLite 显式 IPC backend 探测、FEMLite worker mock 状态和协议对齐状态。 ## 4. 真实 worker 状态 当前本地审计结果: -1. SPHLite 0.8.2 能识别 worker CLI,但真实 Windows IPC 返回受控 unsupported; -2. FEMLite 0.6.4 已提供自运行 worker mock,可完成 1 step mock 闭环; -3. FEMLite 0.6.4 尚未接受 CCLite 标准 IPC worker 参数中的 `--solver-id` 和 `--timeout-ms`; -4. 0.1.x 的可执行验收路径仍是 CCLite mock worker; -5. 0.2.x 前必须先在 SPHLite/FEMLite 侧补齐真实 IPC worker adapter。 +1. 当前 SPHLite 包报告 `cclite_worker=yes`、`supports_real_ipc=yes`、`supports_sph_to_ccl_particle=yes` 和 `supports_ccl_to_sph_force=yes`; +2. 当前 FEMLite 包报告 `cclite_worker=yes`、`worker_mock=yes`、`supports_real_ipc=yes`、`supports_fem_to_ccl_facet=yes` 和 `supports_ccl_to_fem_load=yes`; +3. 两个 worker 在没有预创建 IPC 资源时均会尝试真实 IPC attach,并返回可识别的 attach/open 失败; +4. FEMLite worker mock 新输出格式已被识别为 `WORKER_MOCK_AVAILABLE`; +5. 当前状态为 `EXTERNAL_WORKERS_READY_CCLITE_PROTOCOL_ADAPTER_REQUIRED`,即外部 worker 能力已具备,但 CCLite 侧仍需补齐协议/命名 adapter 和进程级 gate; +6. 0.1.x 的可执行验收路径仍是 CCLite mock worker,不声明真实 SPH-FEM 接触物理完成。 ## 5. 进入 0.2.x 的条件 @@ -45,4 +46,5 @@ 2. CCLite 可按 step 调度两个 worker; 3. 空 force/load 写回路径已存在; 4. checker 可自动判定通信闭环; -5. 真实 worker 缺口已记录,不会误判为物理算法完成。 +5. 外部 worker 能力和协议对齐状态已记录,不会把 `supports_real_ipc=yes` 误判为真实物理算法完成; +6. 若 0.2.x 需要直接使用真实 SPHLite/FEMLite worker,应先完成 CCLite 协议 adapter 和 1 step/100 step 外部空耦合 gate。 diff --git a/docs/07_real_worker_access_audit.md b/docs/07_real_worker_access_audit.md index 877add2..6b7e6ba 100644 --- a/docs/07_real_worker_access_audit.md +++ b/docs/07_real_worker_access_audit.md @@ -2,35 +2,45 @@ ## 1. 审计结论 -CCLite 0.1.9 已固化真实 worker/service 的启动参数,并完成对当前本地 SPHLite/FEMLite 可执行程序的只读审计。 +CCLite 0.1.10 已将真实 worker 审计从“参数是否存在”升级为“能力查询、真实 IPC attach 行为和协议对齐状态”三层检查。 -当前结论为受控缺口: +当前结论为: -1. SPHLite 0.8.2 已识别 `--cclite-worker`、`--solver-id`、`--case`、`--ipc-name` 和 `--timeout-ms` 参数,但真实 Windows shared memory / named event IPC 尚未实现,程序返回受控 unsupported。 -2. FEMLite 0.6.4 已提供自运行的 CCLite worker mock,可用 `--case`、`--ipc-name`、`--log`、`--output-dir` 和 `--mock-steps` 完成 worker mock 闭环。 -3. FEMLite 0.6.4 尚未接受 CCLite 0.1.x 标准 IPC worker 参数中的 `--solver-id` 和 `--timeout-ms`,主程序也尚未切换为真实跨进程 Windows IPC worker 主循环。 -4. CCLite 0.1.9 的工程验收路径仍采用内置 mock worker 完成 1 step 与 100 step 空耦合闭环。 -5. 真实 IPC worker 不在 0.1.9 中伪装为已接入;后续必须在 SPHLite/FEMLite 侧补齐真实 IPC worker adapter 后再进入真实联调。 +```text +EXTERNAL_WORKERS_READY_CCLITE_PROTOCOL_ADAPTER_REQUIRED +``` + +含义是: + +1. 当前 SPHLite 包已提供 `--cclite-capabilities`,并报告 `cclite_worker=yes`、`supports_real_ipc=yes`、`supports_sph_to_ccl_particle=yes` 和 `supports_ccl_to_sph_force=yes`。 +2. 当前 FEMLite 包已提供 `--cclite-capabilities`,并报告 `cclite_worker=yes`、`worker_mock=yes`、`supports_real_ipc=yes`、`supports_fem_to_ccl_facet=yes` 和 `supports_ccl_to_fem_load=yes`。 +3. 两个 worker 在没有 CCLite 预创建 IPC 资源时都会尝试打开真实 IPC,并返回可识别的 attach/open 失败,而不是旧版本的参数缺失或未实现。 +4. FEMLite worker mock 仍可运行,当前输出为 `CCLite worker completed: mock`。 +5. CCLite 0.1.10 尚不声明真实外部 SPHLite/FEMLite 进程联调完成,因为 FEMLite 发布的 IPC 结构和命名规则与 CCLite 0.1.x 当前通用 command/data block 不完全一致,仍需要 CCLite 侧协议/命名 adapter 和进程级 gate。 ## 2. CCLite 固化的 worker 参数 -真实 worker 应支持: +真实 worker 应至少支持: ```text --cclite-worker --solver-id --case --ipc-name --timeout-ms ``` -参数含义: +CCLite 0.1.10 启动 worker 时还会补充新版求解器可识别的辅助参数: -| 参数 | 含义 | -| --- | --- | -| `--cclite-worker` | 进入 CCLite worker/service 模式 | -| `--solver-id` | `SPH` 或 `FEM` | -| `--case` | 求解器自身输入文件 | -| `--ipc-name` | CCLite 分配的 IPC 名称前缀 | -| `--timeout-ms` | worker 等待命令的超时时间 | +```text +--command-block +--data-prefix +--worker-id +``` -CCLite mock worker 同时兼容旧的 `--ipc-prefix` 和 `--solver-input`,但正式参数以 `--ipc-name` 和 `--case` 为准。 +FEMLite worker 额外使用: + +```text +--worker-backend ipc +``` + +这些参数用于补齐启动契约;它们不代表二进制协议已经自动兼容。 ## 3. 当前真实 worker 审计结果 @@ -40,56 +50,91 @@ CCLite mock worker 同时兼容旧的 `--ipc-prefix` 和 `--solver-input`,但 build-codex-gcc/output/real_worker_gap_report.json ``` -SPHLite 标准 IPC worker 探测: +当前审计报告包含: + +1. `sphlite_capabilities`:SPHLite 能力查询; +2. `femlite_capabilities`:FEMLite 能力查询; +3. `sphlite_standard_ipc`:SPHLite 标准 worker 参数 attach 探测; +4. `femlite_standard_ipc`:FEMLite 标准 worker 参数 attach 探测; +5. `femlite_explicit_ipc_backend`:FEMLite `--worker-backend ipc` attach 探测; +6. `femlite_worker_mock`:FEMLite 自运行 worker mock 探测; +7. `protocol_alignment`:CCLite 当前协议与外部 worker 已发布协议的对齐状态。 + +SPHLite 标准 IPC worker 探测当前应表现为: ```text -worker_state: ERROR -solver_id: SPH -error_message: CCLite worker IPC is not implemented yet +status: IPC_ATTACH_ATTEMPTED +recognized_worker_cli: true +real_ipc_attach_attempted: true ``` -FEMLite 标准 IPC worker 探测: +FEMLite 标准 IPC worker 探测当前应表现为: ```text -unknown worker argument: --solver-id +status: IPC_ATTACH_ATTEMPTED +recognized_worker_cli: true +real_ipc_attach_attempted: true ``` -FEMLite worker mock 探测: +FEMLite worker mock 探测当前应表现为: ```text -CCLite worker mock completed +status: WORKER_MOCK_AVAILABLE ``` -## 4. 后续接入条件 +## 4. 协议对齐状态 -SPHLite 进入真实空耦合前必须完成: +CCLite 0.1.x 当前内部协议为: -1. 打开 CCLite 创建的 command block; -2. 打开 `SPH_TO_CCL_PARTICLE` 与 `CCL_TO_SPH_FORCE` data block; -3. 打开并等待 command event; -4. 回写 `READY/DONE/STOPPED`、`ack_seq` 和 `error_code`; -5. 导出空或固定 SPH particle block; -6. 接收空 `CCL_TO_SPH_FORCE` block。 +```text +command block: CCLite generic command block v1 +data header: CCLite generic data block header v0.1 +control name: _CCL_COMMAND_ +event names: _EVENT_COMMAND_, _EVENT_ACK_ +data names: _ +``` -FEMLite 进入真实空耦合前必须完成: +SPHLite 当前文档中的默认命名为: -1. 保留当前 `--cclite-worker` worker mock; -2. 支持与 CCLite 标准 IPC worker 一致的 `--solver-id` 和 `--timeout-ms` 参数; -3. 打开 CCLite 创建的 command block; -4. 打开 `FEM_TO_CCL_FACET` 与 `CCL_TO_FEM_LOAD` data block; -5. 回写 `READY/DONE/STOPPED`、`ack_seq` 和 `error_code`; -6. 导出空或固定 FEM facet block; -7. 接收空 `CCL_TO_FEM_LOAD` block。 +```text +.command +.command_event +.done_event +``` -## 5. 0.1.9 验收口径 +SPHLite 支持 `--command-block` 和 `--data-prefix` 覆盖部分名称,但真实外部 CCLite 进程联调仍需要 CCLite 侧 adapter gate 验收。 -0.1.9 不声明真实 SPHLite/FEMLite IPC worker 已接入。 +FEMLite 当前发布的真实 IPC worker 使用: -0.1.9 完成以下工程目标: +```text +_COMMAND_BLOCK +_COMMAND_EVENT +_DONE_EVENT +_FEM_TO_CCL_FACET +_CCL_TO_FEM_LOAD +``` -1. CCLite 主控的 worker 参数已固化; -2. mock worker 使用同一参数集合; -3. 真实 SPHLite/FEMLite 可执行程序审计可自动生成分层能力报告; -4. FEMLite worker mock 可用时,审计报告显示 `WORKER_MOCK_AVAILABLE`; -5. 若本地缺少 SPHLite/FEMLite 包,审计测试不会阻塞 CCLite 自身构建; -6. 0.1.x 通信闭环仍由 CCLite mock worker 验收。 +并在 `FEMLite/cpu_release/include/femlite_cclite_ipc.h` 中发布了 `femlite_cclite_command_block` 与 `femlite_cclite_data_header`。该结构与 CCLite 0.1.x 当前通用 block 不是同一二进制布局,因此 CCLite 后续必须增加外部协议 adapter 或统一 05 号接口控制文档中的二进制契约。 + +## 5. 0.1.10 验收口径 + +0.1.10 完成以下工程目标: + +1. CCLite 可自动读取 SPHLite/FEMLite 的 `--cclite-capabilities` 输出; +2. 真实 worker attach 失败被识别为 `IPC_ATTACH_ATTEMPTED`,不再误判为参数缺失或未实现; +3. FEMLite 新版 mock 输出 `CCLite worker completed: mock` 被识别为 `WORKER_MOCK_AVAILABLE`; +4. 审计报告明确输出 `CCLITE_PROTOCOL_ADAPTER_REQUIRED`; +5. CCLite 主控启动 worker 时补充 `--command-block`、`--data-prefix`、`--worker-id`,FEMLite 补充 `--worker-backend ipc`; +6. 0.1.x 可执行验收路径仍由 CCLite 内置 mock worker 完成; +7. 真实 SPH-FEM 接触力、真实外部双 worker 联调、摩擦、FSI 和 Linux/MPI 不在 0.1.10 中声明完成。 + +## 6. 后续接入条件 + +进入真实外部 worker 空耦合前,CCLite 侧必须完成: + +1. 明确采用统一 CCLite 05 号通用 block,还是为 SPHLite/FEMLite 各自协议增加 adapter; +2. 建立 `真实 SPHLite + mock FEM` 的 1 step 和 100 step 空耦合 gate; +3. 建立 `mock SPH + 真实 FEMLite` 的 1 step 和 100 step 空耦合 gate; +4. 建立 `真实 SPHLite + 真实 FEMLite` 的 1 step 和 100 step 空耦合 gate; +5. 将能力查询、协议版本、record stride、block 容量和错误码纳入自动报告; +6. 在上述 gate 通过前,不把 `supports_real_ipc=yes` 解释为真实外部联调完成。 diff --git a/src/common/ccl_version.f90 b/src/common/ccl_version.f90 index a518895..9b53ebf 100644 --- a/src/common/ccl_version.f90 +++ b/src/common/ccl_version.f90 @@ -3,8 +3,8 @@ module ccl_version integer, parameter :: CCL_VERSION_MAJOR = 0 integer, parameter :: CCL_VERSION_MINOR = 1 - integer, parameter :: CCL_VERSION_PATCH = 9 - character(len=*), parameter :: CCL_VERSION_LABEL = "0.1.9" + integer, parameter :: CCL_VERSION_PATCH = 10 + character(len=*), parameter :: CCL_VERSION_LABEL = "0.1.10" contains diff --git a/src/controller/ccl_controller.f90 b/src/controller/ccl_controller.f90 index 04201d2..1517f33 100644 --- a/src/controller/ccl_controller.f90 +++ b/src/controller/ccl_controller.f90 @@ -466,9 +466,15 @@ contains command_line = trim(quote_argument(worker%executable)) // " --cclite-worker --solver-id " // & trim(worker%solver_name) // " --ipc-name " // trim(worker%prefix) // " --timeout-ms " // & trim(int_to_string(worker%timeout_ms)) + if (trim(worker%solver_name) == "FEM") then + command_line = trim(command_line) // " --worker-backend ipc" + end if if (len_trim(worker%input_file) > 0) then command_line = trim(command_line) // " --case " // trim(quote_argument(worker%input_file)) end if + command_line = trim(command_line) // " --command-block " // trim(quote_argument(worker%command_name)) // & + " --data-prefix " // trim(quote_argument(worker%prefix)) // & + " --worker-id " // trim(quote_argument(worker%solver_name)) end subroutine build_worker_command_line character(len=CCL_TEXT_LEN) function quote_argument(text) result(quoted)