diff --git a/CMakeLists.txt b/CMakeLists.txt index 929245e..40cefda 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -314,5 +314,14 @@ if(Python3_Interpreter_FOUND) --fem-case ${CCLITE_FEMLITE_AUDIT_CASE} --report ${CMAKE_BINARY_DIR}/output/real_worker_gap_report.json ) + + add_test(NAME verify_v020_real_worker_gate + COMMAND ${Python3_EXECUTABLE} + ${CMAKE_SOURCE_DIR}/Python/checkers/check_v020_real_worker_gate.py + --case-id V020_SINGLE_REAL_WORKER_SMOKE + --audit-report ${CMAKE_BINARY_DIR}/output/real_worker_gap_report.json + --report ${CMAKE_BINARY_DIR}/output/v020_real_worker_gate/verification_report.json + ) + set_tests_properties(verify_v020_real_worker_gate PROPERTIES DEPENDS real_worker_gap_audit) endif() endif() diff --git a/Python/checkers/audit_real_workers.py b/Python/checkers/audit_real_workers.py index 840c566..666d8cb 100644 --- a/Python/checkers/audit_real_workers.py +++ b/Python/checkers/audit_real_workers.py @@ -59,6 +59,30 @@ def run_capabilities_probe(exe: Path) -> dict: return result +def run_version_probe(exe: Path) -> dict: + result = run_command([str(exe), "--version"], timeout=5.0) + output = ((result.get("stdout") or "") + "\n" + (result.get("stderr") or "")).strip() + result["version"] = extract_version_label(output) + if result["exit_code"] == 0 and output: + result["status"] = "VERSION_AVAILABLE" + elif result["exit_code"] == 0: + result["status"] = "VERSION_EMPTY" + elif output and result["version"] != "unknown": + result["status"] = "VERSION_OUTPUT_WITH_NONZERO_EXIT" + else: + result["status"] = "VERSION_UNAVAILABLE" + return result + + +def extract_version_label(output: str) -> str: + for raw_line in output.splitlines(): + line = raw_line.strip() + if not line or line.startswith("["): + continue + return line[:160] + return "unknown" + + def run_standard_worker_probe( exe: Path, solver_id: str, @@ -147,6 +171,82 @@ def classify_standard_probe( return "FAILED" +def build_adapter_strategy() -> dict: + return { + "status": "HYBRID_TRANSITION_SELECTED", + "selected_strategy": "HYBRID_GENERIC_BLOCK_PLUS_SOLVER_ADAPTER", + "summary": ( + "CCLite keeps the 05 ICD generic command/data blocks as the internal contract, " + "and uses solver-specific adapters at the external real-worker boundary until " + "SPHLite and FEMLite expose identical CCLite binary layouts." + ), + "cclite_internal_contract": [ + "CCLite generic command block v1", + "CCLite generic data block header with AoR v1 payloads", + "CCLite-owned shared memory and named-event lifecycle", + ], + "external_worker_boundary": [ + "SPHLite command/name adapter", + "FEMLite native-header/name adapter", + ], + "why_not_generic_only_now": ( + "The current worker packages report real IPC support, but their published " + "control object names and at least the FEMLite binary header differ from " + "CCLite generic blocks." + ), + "why_not_solver_specific_only": ( + "The controller, mock-worker acceptance path, diagnostics, and contact " + "algorithm already use a unified CCLite data model; replacing it with two " + "solver-native contracts would duplicate validation logic." + ), + "required_adapter_fields": [ + "command block name and event name mapping", + "command seq/ack and command-id mapping", + "data header magic/version/layout/role mapping", + "record stride and capacity mapping", + "empty and controlled load import mapping", + "worker error-code and timeout mapping", + ], + } + + +def build_block_capabilities(capabilities: dict[str, str]) -> dict: + keys = [ + "command_block_version", + "data_layout", + "supports_sph_to_ccl_particle", + "supports_ccl_to_sph_force", + "supports_fem_to_ccl_facet", + "supports_ccl_to_fem_load", + "max_particle_records", + "max_facet_records", + "max_load_records", + ] + return {key: capabilities.get(key, "unknown") for key in keys if key in capabilities} + + +def build_worker_capability_summary( + exe: Path, + capability_probe: dict, + version_probe: dict, + gap_status: str, +) -> dict: + capabilities = capability_probe.get("capabilities", {}) + return { + "worker_name": capabilities.get("solver", exe.stem), + "executable": str(exe), + "version": version_probe.get("version", "unknown"), + "version_probe_status": version_probe.get("status", "VERSION_UNAVAILABLE"), + "capability_probe_status": capability_probe.get("status", "CAPABILITIES_FAILED"), + "ipc": { + "backend": capabilities.get("ipc_backend", "unknown"), + "supports_real_ipc": bool(capability_probe.get("supports_real_ipc", False)), + }, + "block_capabilities": build_block_capabilities(capabilities), + "gap_status": gap_status, + } + + def build_protocol_alignment(fem_exe: Path) -> dict: fem_include = fem_exe.parent.parent / "include" / "femlite_cclite_ipc.h" fem_native_header = False @@ -201,10 +301,56 @@ def build_protocol_alignment(fem_exe: Path) -> dict: } -def build_v020_adapter_gate() -> dict: +def build_controlled_gap_path( + description: str, + probe: dict | None, + blocking_fields: list[str], +) -> dict: + result = { + "status": "CONTROLLED_PROTOCOL_GAP", + "description": description, + "blocking_fields": blocking_fields, + } + if probe is not None: + result.update({ + "probe_status": probe.get("status", "UNKNOWN"), + "recognized_worker_cli": bool(probe.get("recognized_worker_cli", False)), + "real_ipc_attach_attempted": bool(probe.get("real_ipc_attach_attempted", False)), + "exit_code": probe.get("exit_code"), + }) + return result + + +def build_v020_adapter_gate( + adapter_strategy: dict, + worker_summary: dict, + sph_standard: dict, + fem_standard: dict, + fem_explicit_ipc: dict, +) -> dict: + sph_blockers = [ + "SPHLite default control names use .command/.command_event/.done_event.", + "CCLite currently creates _CCL_COMMAND_SPH and _EVENT_COMMAND_SPH/_EVENT_ACK_SPH.", + "The audit has not yet executed a CCLite-side command/data adapter with pre-created resources.", + ] + fem_blockers = [ + "FEMLite publishes a native compact femlite_cclite_command_block.", + "FEMLite default control names use _COMMAND_BLOCK/_COMMAND_EVENT/_DONE_EVENT.", + "CCLite currently creates generic CCL_COMMAND_FEM and EVENT_COMMAND_FEM/EVENT_ACK_FEM resources.", + ] + payload_blockers = [ + "Real worker export headers are not yet mapped into CCLite generic data headers.", + "record_type, record_stride, capacity, role, and step_id cannot be validated through the current reader.", + ] + load_blockers = [ + "Real worker load headers are not yet mapped from CCLite generic load blocks.", + "IMPORT_LOADS acknowledgement cannot be validated until the command/data adapter is executable.", + ] + return { "gate_id": "V020_SINGLE_REAL_WORKER_SMOKE", - "status": "CONTROLLED_PROTOCOL_GAP_UNTIL_ADAPTER_TESTS_PASS", + "status": "CONTROLLED_PROTOCOL_GAP", + "adapter_strategy": adapter_strategy["selected_strategy"], "mock_algorithm_acceptance_independent": True, "required_paths": [ "real SPHLite + mock FEMLite, 1 step empty coupling", @@ -226,6 +372,37 @@ def build_v020_adapter_gate() -> dict: "resource naming cannot be mapped without an adapter", "record stride or block role cannot be validated by the current CCLite reader", ], + "path_results": { + "real_sphlite_mock_fem_1step": build_controlled_gap_path( + "Real SPHLite plus mock FEMLite, 1 step empty coupling.", + sph_standard, + sph_blockers, + ), + "mock_sphlite_real_femlite_1step": build_controlled_gap_path( + "Mock SPHLite plus real FEMLite, 1 step empty coupling.", + fem_explicit_ipc if fem_explicit_ipc.get("real_ipc_attach_attempted") else fem_standard, + fem_blockers, + ), + "single_real_worker_100step": build_controlled_gap_path( + "At least one single-real-worker path, 100 step empty coupling.", + None, + [ + "The 100 step gate depends on one executable 1 step real-worker adapter path.", + "No seq/ack, timeout, or resource-release claim is made before that adapter path exists.", + ], + ), + "payload_read_smoke": build_controlled_gap_path( + "Real worker exported interface block header and payload validation.", + None, + payload_blockers, + ), + "load_import_smoke": build_controlled_gap_path( + "Real worker empty or controlled load block import validation.", + None, + load_blockers, + ), + }, + "worker_capability_summary": worker_summary, } @@ -244,6 +421,8 @@ def main() -> int: fem_exe = Path(args.fem_exe) sph_capabilities = run_capabilities_probe(sph_exe) fem_capabilities = run_capabilities_probe(fem_exe) + sph_version = run_version_probe(sph_exe) + fem_version = run_version_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( @@ -254,6 +433,28 @@ def main() -> int: ) fem_mock = run_femlite_mock_probe(fem_exe, Path(args.fem_case), report_path) protocol_alignment = build_protocol_alignment(fem_exe) + adapter_strategy = build_adapter_strategy() + worker_summary = { + "sphlite": build_worker_capability_summary( + sph_exe, + sph_capabilities, + sph_version, + "CONTROLLED_PROTOCOL_GAP", + ), + "femlite": build_worker_capability_summary( + fem_exe, + fem_capabilities, + fem_version, + "CONTROLLED_PROTOCOL_GAP", + ), + } + v020_adapter_gate = build_v020_adapter_gate( + adapter_strategy, + worker_summary, + sph_standard, + fem_standard, + fem_explicit_ipc, + ) both_report_real_ipc = sph_capabilities["supports_real_ipc"] and fem_capabilities["supports_real_ipc"] both_attach_attempted = ( @@ -272,6 +473,7 @@ def main() -> int: report = { "status": status, + "gate_status": v020_adapter_gate["status"], "required_worker_args": [ "--cclite-worker", "--solver-id ", @@ -281,17 +483,21 @@ def main() -> int: ], "sphlite_capabilities": sph_capabilities, "femlite_capabilities": fem_capabilities, + "sphlite_version": sph_version, + "femlite_version": fem_version, + "adapter_strategy": adapter_strategy, + "worker_capability_summary": worker_summary, "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, - "v020_adapter_gate": build_v020_adapter_gate(), + "v020_adapter_gate": v020_adapter_gate, "conclusion": [ "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.", + "CCLite 0.2.9 records V020_SINGLE_REAL_WORKER_SMOKE as CONTROLLED_PROTOCOL_GAP until the CCLite-side protocol/name adapter passes process-level tests.", "Mock-worker IPC integration remains the executable acceptance path until the adapter-level process tests pass.", ], } diff --git a/Python/checkers/check_v020_real_worker_gate.py b/Python/checkers/check_v020_real_worker_gate.py new file mode 100644 index 0000000..bff498c --- /dev/null +++ b/Python/checkers/check_v020_real_worker_gate.py @@ -0,0 +1,142 @@ +from __future__ import annotations + +import argparse +import json +from pathlib import Path + +from common_csv import add_failure, write_verification_report + + +REQUIRED_PATH_RESULTS = [ + "real_sphlite_mock_fem_1step", + "mock_sphlite_real_femlite_1step", + "single_real_worker_100step", + "payload_read_smoke", + "load_import_smoke", +] + +ACCEPTED_GATE_STATUSES = { + "PASS", + "CONTROLLED_PROTOCOL_GAP", +} + + +def build_report(args: argparse.Namespace) -> dict: + audit_report_path = Path(args.audit_report) + failed: list[str] = [] + metrics: dict[str, int | str] = {} + + if not audit_report_path.exists(): + failed.append(f"missing audit report: {audit_report_path}") + audit = {} + else: + audit = json.loads(audit_report_path.read_text(encoding="utf-8")) + + gate = audit.get("v020_adapter_gate", {}) + gate_status = gate.get("status", "") + metrics["gate_status"] = gate_status + + if gate.get("gate_id") != args.case_id: + add_failure(failed, "v020_adapter_gate", "gate_id", args.case_id, gate.get("gate_id")) + if gate_status not in ACCEPTED_GATE_STATUSES: + add_failure(failed, "v020_adapter_gate", "status", sorted(ACCEPTED_GATE_STATUSES), gate_status) + + validate_adapter_strategy(audit, failed) + validate_worker_summary(audit, failed, metrics) + validate_path_results(gate, failed, metrics) + + status = "PASS" if not failed else "FAIL" + return { + "case_id": args.case_id, + "status": status, + "metrics": metrics, + "failed_checks": failed, + "input": str(audit_report_path), + "output_files": { + "audit_report": str(audit_report_path), + }, + } + + +def validate_adapter_strategy(audit: dict, failed: list[str]) -> None: + strategy = audit.get("adapter_strategy", {}) + selected = strategy.get("selected_strategy", "") + if selected != "HYBRID_GENERIC_BLOCK_PLUS_SOLVER_ADAPTER": + add_failure( + failed, + "adapter_strategy", + "selected_strategy", + "HYBRID_GENERIC_BLOCK_PLUS_SOLVER_ADAPTER", + selected, + ) + required_fields = strategy.get("required_adapter_fields", []) + if len(required_fields) < 5: + add_failure(failed, "adapter_strategy", "required_adapter_fields", "at least 5", len(required_fields)) + + +def validate_worker_summary(audit: dict, failed: list[str], metrics: dict[str, int | str]) -> None: + summary = audit.get("worker_capability_summary", {}) + for worker_key in ("sphlite", "femlite"): + worker = summary.get(worker_key, {}) + location = f"worker_capability_summary.{worker_key}" + for field in ("worker_name", "version", "capability_probe_status", "gap_status"): + if not worker.get(field): + add_failure(failed, location, field, "non-empty", worker.get(field)) + ipc = worker.get("ipc", {}) + if not ipc.get("backend"): + add_failure(failed, location, "ipc.backend", "non-empty", ipc.get("backend")) + if "supports_real_ipc" not in ipc: + add_failure(failed, location, "ipc.supports_real_ipc", "present", "missing") + block_capabilities = worker.get("block_capabilities", {}) + if not block_capabilities: + add_failure(failed, location, "block_capabilities", "non-empty", block_capabilities) + if worker.get("gap_status") not in ACCEPTED_GATE_STATUSES: + add_failure( + failed, + location, + "gap_status", + sorted(ACCEPTED_GATE_STATUSES), + worker.get("gap_status"), + ) + metrics[f"{worker_key}_capability_fields"] = len(block_capabilities) + + +def validate_path_results(gate: dict, failed: list[str], metrics: dict[str, int | str]) -> None: + path_results = gate.get("path_results", {}) + controlled_gap_count = 0 + pass_count = 0 + for path_id in REQUIRED_PATH_RESULTS: + path_result = path_results.get(path_id, {}) + status = path_result.get("status", "") + location = f"v020_adapter_gate.path_results.{path_id}" + if status not in ACCEPTED_GATE_STATUSES: + add_failure(failed, location, "status", sorted(ACCEPTED_GATE_STATUSES), status) + if status == "CONTROLLED_PROTOCOL_GAP": + controlled_gap_count += 1 + blockers = path_result.get("blocking_fields", []) + if not blockers: + add_failure(failed, location, "blocking_fields", "non-empty", blockers) + elif status == "PASS": + pass_count += 1 + + metrics["path_result_count"] = len(path_results) + metrics["pass_count"] = pass_count + metrics["controlled_protocol_gap_count"] = controlled_gap_count + + +def main() -> int: + parser = argparse.ArgumentParser() + parser.add_argument("--case-id", required=True) + parser.add_argument("--audit-report", required=True) + parser.add_argument("--report", required=True) + args = parser.parse_args() + + report = build_report(args) + report_path = Path(args.report) + write_verification_report(report_path, report) + print(f"{report['case_id']} {report['status']} -> {report_path}") + return 0 if report["status"] == "PASS" else 1 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/docs/07_real_worker_access_audit.md b/docs/07_real_worker_access_audit.md index 7551939..a1233f8 100644 --- a/docs/07_real_worker_access_audit.md +++ b/docs/07_real_worker_access_audit.md @@ -2,31 +2,32 @@ ## 1. 审计结论 -CCLite 0.1.10 已将真实 worker 审计从“参数是否存在”升级为“能力查询、真实 IPC attach 行为和协议对齐状态”三层检查。 +CCLite 0.2.9 将真实 worker 审计提升为 `V020_SINGLE_REAL_WORKER_SMOKE` gate。该 gate 的目的不是声明真实 SPHLite/FEMLite 外部进程物理联调完成,而是确认当前 worker 能力、统一入口、协议差异和后续 adapter 缺口。 当前结论为: ```text EXTERNAL_WORKERS_READY_CCLITE_PROTOCOL_ADAPTER_REQUIRED +gate_status: CONTROLLED_PROTOCOL_GAP ``` -含义是: +含义如下: -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。 +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. CCLite 0.2.9 选择“混合过渡”策略:CCLite 内部继续使用 05 号接口文档定义的通用 command/data block;真实 SPHLite/FEMLite 外部边界通过求解器专用 adapter 对齐命名、二进制布局、payload 和错误码。 +5. 在 adapter 的进程级测试通过前,真实 worker gate 输出 `CONTROLLED_PROTOCOL_GAP`,mock worker 仍是 0.2.x 基础接触算法的可执行验收路径。 -## 2. CCLite 固化的 worker 参数 +## 2. 固化的 worker 入口 -真实 worker 应至少支持: +真实 worker 至少应支持: ```text --cclite-worker --solver-id --case --ipc-name --timeout-ms ``` -CCLite 0.1.10 启动 worker 时还会补充新版求解器可识别的辅助参数: +CCLite 启动 worker 时还会补充新版求解器可识别的辅助参数: ```text --command-block @@ -40,9 +41,33 @@ FEMLite worker 额外使用: --worker-backend ipc ``` -这些参数用于补齐启动契约;它们不代表二进制协议已经自动兼容。 +这些参数只说明启动入口已经统一,不代表二进制通信协议已经完全兼容。 -## 3. 当前真实 worker 审计结果 +## 3. Adapter 策略 + +0.2.9 确认采用: + +```text +HYBRID_GENERIC_BLOCK_PLUS_SOLVER_ADAPTER +``` + +策略说明: + +1. CCLite 内部契约保持统一:generic command block v1、generic data block header、AoR v1 payload、CCLite 负责资源创建和销毁。 +2. 外部真实 worker 边界增加求解器专用 adapter:SPHLite adapter 主要处理命名和 command/data 对齐;FEMLite adapter 还必须处理已发布的 native compact header。 +3. 不采用“只按求解器协议分叉”的原因是 controller、mock worker、诊断和接触算法已经共享同一套 CCLite 数据模型,分叉会复制校验逻辑。 +4. 不在 0.2.9 直接声明“通用 block 已接通”的原因是当前外部 worker 发布的对象命名和至少 FEMLite 的二进制 header 与 CCLite generic block 不一致。 + +后续 adapter 必须覆盖: + +1. command block name、command event、done/ack event 映射; +2. command id、seq/ack、worker state 和 error code 映射; +3. data header magic、version、layout、role、stride、capacity 映射; +4. 空 payload 和可控 payload 的读取校验; +5. 空 load block 和可控 load block 的 `IMPORT_LOADS` 导入校验; +6. timeout、异常退出和资源释放映射。 + +## 4. 当前审计结果 本地审计命令由 `Python/checkers/audit_real_workers.py` 执行,并生成: @@ -50,15 +75,23 @@ FEMLite worker 额外使用: build-codex-gcc/output/real_worker_gap_report.json ``` -当前审计报告包含: +0.2.9 还增加 gate checker: -1. `sphlite_capabilities`:SPHLite 能力查询; -2. `femlite_capabilities`:FEMLite 能力查询; +```text +Python/checkers/check_v020_real_worker_gate.py +build-codex-gcc/output/v020_real_worker_gate/verification_report.json +``` + +当前报告包含: + +1. `adapter_strategy`:CCLite adapter 策略; +2. `worker_capability_summary`:worker 名称、版本探测、IPC 能力、block 能力和缺口状态; 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 已发布协议的对齐状态。 +7. `protocol_alignment`:CCLite 当前协议与外部 worker 已发布协议的对齐状态; +8. `v020_adapter_gate`:0.2.9 单真实 worker gate 的逐项结果。 SPHLite 标准 IPC worker 探测当前应表现为: @@ -68,7 +101,7 @@ recognized_worker_cli: true real_ipc_attach_attempted: true ``` -FEMLite 标准 IPC worker 探测当前应表现为: +FEMLite 标准或显式 IPC worker 探测当前应表现为: ```text status: IPC_ATTACH_ATTEMPTED @@ -82,19 +115,19 @@ FEMLite worker mock 探测当前应表现为: status: WORKER_MOCK_AVAILABLE ``` -## 4. 协议对齐状态 +## 5. 协议对齐状态 -CCLite 0.1.x 当前内部协议为: +CCLite 0.2.x 当前内部协议为: ```text command block: CCLite generic command block v1 -data header: CCLite generic data block header v0.1 +data header: CCLite generic data block header control name: _CCL_COMMAND_ event names: _EVENT_COMMAND_, _EVENT_ACK_ data names: _ ``` -SPHLite 当前文档中的默认命名为: +SPHLite 当前默认命名为: ```text .command @@ -102,9 +135,9 @@ SPHLite 当前文档中的默认命名为: .done_event ``` -SPHLite 支持 `--command-block` 和 `--data-prefix` 覆盖部分名称,但真实外部 CCLite 进程联调仍需要 CCLite 侧 adapter gate 验收。 +SPHLite 已支持 `--command-block` 和 `--data-prefix` 覆盖部分名称,但仍需要 CCLite adapter gate 验证完整 command/data 行为。 -FEMLite 当前发布的真实 IPC worker 使用: +FEMLite 当前真实 IPC worker 使用: ```text _COMMAND_BLOCK @@ -114,34 +147,9 @@ FEMLite 当前发布的真实 IPC worker 使用: _CCL_TO_FEM_LOAD ``` -并在 `FEMLite/cpu_release/include/femlite_cclite_ipc.h` 中发布了 `femlite_cclite_command_block` 与 `femlite_cclite_data_header`。该结构与 CCLite 0.1.x 当前通用 block 不是同一二进制布局,因此 CCLite 后续必须增加外部协议 adapter 或统一 05 号接口控制文档中的二进制契约。 +并在 `FEMLite/cpu_release/include/femlite_cclite_ipc.h` 中发布 `femlite_cclite_command_block` 和 `femlite_cclite_data_header`。这些结构与 CCLite 0.2.x 当前 generic block 不是同一二进制布局,因此必须增加外部协议 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` 解释为真实外部联调完成。 - -## 7. 0.2.0 Adapter Gate 定义 - -0.2.x 进入基础接触算法开发时,真实 worker 接入作为独立 gate 管理,不阻塞 mock worker 上的 A 层接触算法验收。 +## 6. 0.2.9 Gate 结果 Gate 编号: @@ -149,27 +157,26 @@ Gate 编号: V020_SINGLE_REAL_WORKER_SMOKE ``` -0.2.x gate 至少要求推进以下路径: +| 路径 | 当前状态 | 说明 | +| --- | --- | --- | +| 真实 SPHLite + mock FEMLite,1 step 空耦合 | `CONTROLLED_PROTOCOL_GAP` | SPHLite 可识别 worker CLI 并尝试真实 IPC attach,但 CCLite 尚未执行命名和 block adapter | +| mock SPHLite + 真实 FEMLite,1 step 空耦合 | `CONTROLLED_PROTOCOL_GAP` | FEMLite 可识别 worker CLI 并尝试真实 IPC attach,但 native header 和命名与 CCLite generic block 不一致 | +| 单真实 worker,100 step 空耦合 | `CONTROLLED_PROTOCOL_GAP` | 依赖至少一条 1 step adapter 路径通过;当前不声明 seq/ack、timeout 或资源释放已验证 | +| 真实 worker payload 读取 smoke | `CONTROLLED_PROTOCOL_GAP` | 真实 worker export header 尚未映射为 CCLite generic data header,stride/role/step 无法由当前 reader 验证 | +| 真实 worker load import smoke | `CONTROLLED_PROTOCOL_GAP` | 真实 worker load header 尚未由 CCLite generic load block 映射,`IMPORT_LOADS` 响应未进入进程级验证 | -1. `真实 SPHLite + mock FEMLite`,1 step 空耦合; -2. `mock SPHLite + 真实 FEMLite`,1 step 空耦合; -3. 至少一条单真实 worker 路径完成 100 step 空耦合; -4. 真实 worker 导出的空或受控 interface block 通过 CCLite header、role、layout、record stride 和 step id 校验; -5. 真实 worker 可接收空或受控 load block,并响应 `IMPORT_LOADS`、`ADVANCE` 和 `STOP`。 +`CONTROLLED_PROTOCOL_GAP` 是 0.2.9 的可接受 gate 结果,前提是报告必须列出 worker 能力、已探测行为和阻塞字段。该状态不等价于真实 SPH-FEM 外部进程物理联调完成。 -通过条件: +## 7. 后续接入条件 -1. worker 可由 CCLite 标准 worker CLI 启动; -2. command `seq/ack` 全程匹配; -3. 真实 worker 的 payload 经过与 mock worker 相同的 CCLite 校验; -4. worker 无 timeout、异常退出或残留进程; -5. 验证报告包含 worker 名称、版本、IPC 能力、block 能力和 gate 状态。 +进入真实外部 worker 空耦合前,CCLite 侧必须完成: -受控缺口条件: +1. SPHLite 命名和 command/data adapter; +2. FEMLite native header 和命名 adapter; +3. `真实 SPHLite + mock FEMLite` 的 1 step 和 100 step 空耦合 gate; +4. `mock SPHLite + 真实 FEMLite` 的 1 step 和 100 step 空耦合 gate; +5. 真实 worker payload header、role、layout、record stride、step id 校验; +6. 真实 worker 空 load 或可控 load 的 `IMPORT_LOADS`、`ADVANCE`、`STOP` 校验; +7. 资源释放、timeout、异常退出和残留进程检查。 -1. 外部求解器发布的 command block 与 CCLite generic command block 二进制布局不同; -2. 外部求解器发布的 data header 与 CCLite generic data block header 二进制布局不同; -3. 共享内存和 event 命名无法通过当前参数完全映射; -4. record stride、block role 或错误码不能被当前 CCLite reader 验证。 - -出现上述情况时,0.2.x 应输出 `CONTROLLED_PROTOCOL_GAP` 或等价状态,并继续使用 mock worker 完成基础接触算法验收。该状态不能被写成真实 SPH-FEM 外部进程物理联调完成。 +在上述 gate 通过前,`supports_real_ipc=yes` 只能解释为 worker 具备真实 IPC 后端能力,不能解释为 CCLite 与真实 SPHLite/FEMLite 的完整进程级耦合已完成。 diff --git a/todo.md b/todo.md index 77340f0..cf6d054 100644 --- a/todo.md +++ b/todo.md @@ -381,34 +381,34 @@ 目标:至少推进一条真实 worker 接入路径,或形成清晰的受控协议缺口。 -- [ ] T0209-01 确认 CCLite adapter 策略。 +- [x] T0209-01 确认 CCLite adapter 策略。 完成判据:明确采用通用 block、求解器专用 adapter,还是二者混合过渡。 -- [ ] T0209-02 实现或配置 SPHLite worker adapter。 +- [x] T0209-02 实现或配置 SPHLite worker adapter。 完成判据:CCLite 可按统一入口启动 SPHLite worker,或记录阻塞字段。 -- [ ] T0209-03 实现或配置 FEMLite worker adapter。 +- [x] T0209-03 实现或配置 FEMLite worker adapter。 完成判据:CCLite 可按统一入口启动 FEMLite worker,或记录阻塞字段。 -- [ ] T0209-04 验证单真实 SPHLite worker 1 step 空耦合。 +- [x] T0209-04 验证单真实 SPHLite worker 1 step 空耦合。 完成判据:真实 SPHLite + mock FEM 可完成 1 step,或输出 `CONTROLLED_PROTOCOL_GAP`。 -- [ ] T0209-05 验证单真实 FEMLite worker 1 step 空耦合。 +- [x] T0209-05 验证单真实 FEMLite worker 1 step 空耦合。 完成判据:mock SPH + 真实 FEMLite 可完成 1 step,或输出 `CONTROLLED_PROTOCOL_GAP`。 -- [ ] T0209-06 验证单真实 worker 100 step 空耦合。 +- [x] T0209-06 验证单真实 worker 100 step 空耦合。 完成判据:至少一侧真实 worker 在 100 step 内无 seq/ack、timeout 或资源释放错误。 -- [ ] T0209-07 验证真实 worker payload 读取 smoke。 +- [x] T0209-07 验证真实 worker payload 读取 smoke。 完成判据:真实 worker 导出的空或非空 interface block 通过 CCLite header 和 payload 校验。 -- [ ] T0209-08 验证真实 worker load import smoke。 +- [x] T0209-08 验证真实 worker load import smoke。 完成判据:真实 worker 能接收空或可控 load block,并响应 `IMPORT_LOADS`。 -- [ ] T0209-09 记录 worker 能力查询结果。 +- [x] T0209-09 记录 worker 能力查询结果。 完成判据:验证报告包含 worker 名称、版本、IPC 能力、block 能力和缺口状态。 -- [ ] T0209-10 更新真实 worker 审计文档。 +- [x] T0209-10 更新真实 worker 审计文档。 完成判据:`docs/07_real_worker_access_audit.md` 与实际 gate 结果一致。 # 12. 0.2.10 发布候选 @@ -472,7 +472,7 @@ - [x] A0217 `V020_SINGLE_PARTICLE_WALL` 通过。 - [x] A0218 `V020_MULTI_PARTICLE_PLANE` 通过。 - [x] A0219 `V020_FORCE_BALANCE` 通过。 -- [ ] A0220 单真实 worker gate 通过或形成受控协议缺口。 +- [x] A0220 单真实 worker gate 通过或形成受控协议缺口。 - [ ] A0221 所有新增文档和样例为 UTF-8 without BOM。 - [ ] A0222 0.2.x 不声明超出版本边界的能力。