首页 理论 架构 工程 规划 文档 白皮书 著作 研究 案例 下载 博客 关于 联系 开始使用 →

第二十六章 个体运行环境与运行引擎

第六篇 个体自主运行工程实现

本篇重点实现个体获得知识能力之后,如何脱离中央控制端的持续逐步指令,依据自身结构、能力和执行规则完成任务。中央控制与个体自主运行是不同层次的工程机制。

第二十六章 个体运行环境与运行引擎

  1. 个体独立运行环境的建立

  2. 个体运行入口与初始化程序

  3. 个体结构加载与运行上下文

  4. 个体运行引擎的程序组织

  5. 个体运行状态与资源管理

    第二十六章 个体运行环境与运行引擎

    个体完成知识能力赋值和部署之后,需要具备独立承载知识结构、能力方法和执行规则的运行环境。个体运行环境是知识能力实际进入运行过程的基础,运行引擎则负责将已经赋予个体的知识结构组织为可以持续处理任务的运行过程。两者共同构成个体自主运行的工程基础。

    WSaiOS采用智能控制后台与个体相分离的工程架构。智能控制后台承担结构智能逻辑、需求驱动、知识结构化构建、知识能力形成与验证、个体智能赋值、项目规划和多智能个体组织控制等工作。个体获得经过构建和验证的知识能力之后,在自身运行环境中完成结构加载、信息获取、对象识别、能力调用、认知判断、决策和方法执行。

    因此,个体运行引擎不是智能控制后台的缩小版本,也不是将后台全部智能逻辑复制到每一个个体中。它的工程任务是承载和运行后台赋予的知识能力,使个体能够根据自身职责处理实际对象和运行信息,并按照赋值时确定的执行规则完成任务。

    个体运行环境也不是单纯的程序安装目录。它需要同时解决程序运行、知识结构存储、能力加载、方法调用、运行上下文管理、数据访问、资源使用和执行状态管理等问题。对于软件个体,运行环境可以由独立进程、运行目录、数据存储和程序组件组成;对于机器人、无人机和工业设备等实体个体,运行环境还需要与设备控制器、传感器、执行机构及本地计算单元建立对应关系。

    本章从个体独立运行环境的建立出发,研究运行入口、初始化程序、结构加载、运行上下文、运行引擎的程序组织,以及个体运行状态与资源管理,形成个体获得知识能力之后能够独立运行的工程基础。

    第一节 个体独立运行环境的建立

    个体独立运行环境的建立,首先需要明确个体与智能控制后台之间的工程边界。后台负责构建和管理知识能力,个体负责在自身运行环境中加载和执行已经赋予的知识能力。个体不需要在运行过程中反复向后台请求每一个判断步骤,也不需要将所有实际处理过程交由后台完成。只要个体已经获得完成当前任务所需的结构、能力、方法和执行规则,并且本地运行条件满足要求,就可以按照自身运行机制开展工作。

    独立运行环境的建立,需要以个体对象标识为基础。每个个体都应当具有稳定的individual_id,用于区分不同运行主体,并与后台保存的个体定义、赋值记录和部署版本建立关联。个体运行环境不能仅依靠设备名称、网络地址或进程名称进行识别,因为这些信息可能发生变化,而个体身份需要在设备迁移、进程重启或通信中断后仍然保持稳定。

    对于软件个体,独立运行环境通常由独立的运行目录、程序入口、配置文件、知识结构目录、能力目录、方法目录、运行数据目录和日志目录构成。不同个体可以使用同一套基础运行引擎程序,但应当通过独立的个体配置和赋值清单确定自身运行内容。这样既能避免为每个个体重复开发一套运行程序,也能保证不同个体之间的知识能力和运行数据相互隔离。

    例如,某个工程系统中存在三个软件个体,分别承担对象识别、任务分析和执行控制职能。三个个体可以共用同一套运行引擎程序,但每个个体拥有自己的身份标识、赋值版本、结构定义、能力清单和运行上下文。运行引擎根据当前个体的身份读取对应配置,加载相应知识能力,不会因为三个个体共用程序而自动获得相同的能力。

    工程目录可以采用如下组织方式:

    IndividualRuntime/                         # 个体独立运行环境的根目录
    ├── engine/                                 # 个体运行引擎程序目录
    │   ├── RuntimeKernel.php                   # 个体运行核心调度程序
    │   ├── RuntimeBootstrap.php                # 个体运行环境启动程序
    │   └── RuntimeContainer.php                # 管理运行期间的程序依赖
    │
    ├── individuals/                            # 个体运行实例目录
    │   └── individual_001/                     # 某一个体的独立运行目录
    │       ├── config/                         # 个体运行配置目录
    │       │   ├── runtime.json                # 个体运行参数配置
    │       │   └── environment.json             # 个体运行环境描述
    │       │
    │       ├── assignment/                     # 个体智能赋值目录
    │       │   ├── manifest.json               # 当前赋值清单
    │       │   └── version.json                # 当前赋值版本信息
    │       │
    │       ├── structures/                     # 个体已赋值的知识结构目录
    │       │   └── definitions/                # 对象、属性、关系及状态结构定义
    │       │
    │       ├── capabilities/                   # 个体知识能力目录
    │       │   └── definitions/                # 能力定义及能力关联数据
    │       │
    │       ├── methods/                        # 个体可调用方法目录
    │       │   ├── registry.json               # 方法注册信息
    │       │   └── implementations/             # 经授权交付的方法实现程序
    │       │
    │       ├── rules/                           # 个体执行规则目录
    │       │   └── execution_rules.json        # 个体执行约束与规则定义
    │       │
    │       ├── data/                            # 个体运行数据目录
    │       │   ├── objects/                    # 实际对象实例及对象状态数据
    │       │   ├── tasks/                      # 个体接收和处理的任务数据
    │       │   └── context/                    # 当前任务运行上下文数据
    │       │
    │       ├── storage/                         # 个体本地持久化存储目录
    │       │   ├── state/                      # 个体运行状态存储
    │       │   └── checkpoints/                # 运行检查点及恢复数据
    │       │
    │       ├── logs/                            # 个体运行日志目录
    │       │   ├── runtime.log                 # 运行过程日志
    │       │   ├── method.log                  # 方法调用记录
    │       │   └── error.log                   # 运行异常记录
    │       │
    │       └── cache/                           # 个体运行缓存目录
    │           ├── structure/                  # 已加载知识结构缓存
    │           └── capability/                 # 已加载知识能力缓存
    │
    └── shared/                                 # 多个个体可以共同使用的基础资源目录
        ├── libraries/                          # 公共运行程序库
        └── interfaces/                         # 通用数据和设备接口定义

    上述目录描述的是一种拟定的工程组织方式。实际部署时,软件个体可以采用独立目录,也可以采用统一运行程序加个体数据分区的方式。实体设备则需要根据本地计算资源和设备操作系统,将相应目录映射到实际存储介质中。

    这里需要特别区分个体独立运行环境与共享运行程序。多个个体可以共用经过验证的基础运行引擎,但个体的赋值清单、知识结构、任务状态和运行上下文必须按照个体身份进行隔离。公共运行程序的更新也不能直接改变每个个体已经生效的赋值版本。

    个体运行环境中的知识结构和能力数据,需要明确其来源和版本。后台在完成个体智能赋值后,将相应的结构定义、能力定义、方法关联和执行规则交付给个体。个体接收后应当根据赋值清单进行检查,确认文件内容、版本标识和依赖关系一致,避免加载不完整或错误关联的知识能力。

    对于运行环境的存储方式,可以根据个体类型采用本地文件、数据库或嵌入式存储。软件个体可以使用JSON文件保存相对稳定的结构定义,使用数据库保存需要频繁更新的对象实例、运行状态和任务记录。资源受限的实体个体可以采用本地文件与轻量级数据库结合的方式。具体存储技术应当服从个体运行环境的实际条件,而不是要求所有个体采用相同的数据库结构。

    个体运行环境还需要具备资源边界。不同个体可以具有不同的处理器、内存、存储空间、传感器、执行机构和通信条件。后台在赋值时应当考虑这些条件,不能把个体无法加载或执行的知识能力直接部署到该个体中。运行环境建立时需要检查本地程序版本、存储空间、可用内存、必要接口和设备状态,确保赋值内容与实际运行条件相适应。

    对于实体设备,运行环境还需要建立设备资源与知识结构之间的关联。例如,个体具有移动能力,并不意味着任何移动方法都可以直接控制实际电机。运行引擎必须通过设备接口访问经过定义和验证的控制资源,并检查设备当前状态、操作范围和执行约束。知识能力决定个体依据什么结构进行判断,设备接口则负责将允许执行的方法转换为实际设备操作。

    因此,个体独立运行环境的建立,最终要形成三个相互关联的工程基础:一是个体自身的程序运行环境,二是后台赋予个体的知识能力运行数据,三是个体实际能够访问的本地资源和外部设备接口。只有这三部分能够正确关联,个体才具备进入自主运行阶段的条件。

    第二节 个体运行入口与初始化程序

    个体运行入口是个体运行引擎启动整个运行过程的程序入口。它负责读取个体身份、定位运行环境、加载基础配置、调用初始化程序,并将个体运行状态交给运行引擎管理。

    运行入口不能直接承担全部运行逻辑。若将配置读取、知识结构加载、能力初始化、方法注册、设备连接和任务执行全部写入一个入口文件,随着个体运行机制扩展,程序之间会形成严重耦合,也难以针对不同个体采用不同的初始化流程。

    因此,个体运行入口应当保持相对稳定,具体初始化工作交给不同的初始化程序完成。入口程序只负责建立启动过程和组织初始化调用,不直接负责执行具体知识能力。

    对于软件个体,可以采用独立的启动文件:

    individual_001/
    ├── start.php                    # 个体运行入口
    ├── config/
    │   └── runtime.json             # 个体运行配置
    └── engine/
        └── RuntimeInitializer.php   # 个体初始化程序

    start.php负责接收启动请求,读取当前个体身份,并调用运行引擎启动程序。runtime.json保存个体运行所需的基本参数。RuntimeInitializer.php负责检查运行环境和初始化必要的运行对象。

    个体启动时,首先需要确定当前运行主体。个体身份可以通过本地配置、部署清单或启动参数获得,但必须与后台建立的个体身份保持一致。不能仅根据当前目录名称推断个体身份,因为运行目录可能迁移,也可能由多个个体共用。

    一个简化的运行入口可以设计为:

    <?php
    
    require_once __DIR__ . '/engine/RuntimeBootstrap.php';
    
    $individualId = 'individual_001';
    
    $bootstrap = new RuntimeBootstrap(
        __DIR__,
        $individualId
    );
    
    $result = $bootstrap->start();
    
    if (!$result['success']) {
        exit("Individual runtime initialization failed.");
    }

    这里的individualId在实际部署中应当由经过验证的本地配置或启动参数提供,示例中的固定值仅用于说明调用关系。

    RuntimeBootstrap.php负责启动初始化过程:

    <?php
    
    class RuntimeBootstrap
    {
        private $basePath;
        private $individualId;
    
        public function __construct($basePath, $individualId)
        {
            $this->basePath = $basePath;
            $this->individualId = $individualId;
        }
    
        public function start()
        {
            $initializer = new RuntimeInitializer(
                $this->basePath,
                $this->individualId
            );
    
            $result = $initializer->initialize();
    
            if (!$result['success']) {
                return $result;
            }
    
            return array(
                'success' => true,
                'individual_id' => $this->individualId,
                'runtime_status' => 'initialized'
            );
        }
    }

    RuntimeInitializer是实际初始化过程的组织者。它需要根据个体类型和赋值清单,逐步检查并建立运行环境。初始化过程不能仅检查程序文件是否存在,还需要检查知识能力的依赖是否完整、当前赋值版本是否有效,以及本地运行条件是否满足。

    初始化程序可以按照工程职责拆分:

    engine/
    └── Initialization/
        ├── RuntimeInitializer.php          # 统一组织个体运行初始化
        ├── IndividualIdentityLoader.php    # 加载并验证个体身份
        ├── RuntimeConfigLoader.php         # 加载个体运行配置
        ├── AssignmentManifestLoader.php    # 加载个体智能赋值清单
        ├── EnvironmentChecker.php          # 检查本地运行环境
        ├── DependencyChecker.php           # 检查知识能力依赖
        ├── RuntimeResourceInitializer.php  # 初始化运行资源
        └── InitializationResult.php        # 保存初始化结果

    IndividualIdentityLoader读取个体身份信息,并检查其与本地部署信息是否一致。RuntimeConfigLoader读取运行参数和运行模式。AssignmentManifestLoader读取当前赋值清单和赋值版本。EnvironmentChecker检查程序运行环境、存储资源及必要接口。DependencyChecker检查赋值内容依赖的知识结构、方法实现和执行规则是否完整。RuntimeResourceInitializer建立后续运行所需的上下文、缓存和资源管理对象。InitializationResult保存初始化过程的检查结果。

    初始化程序应当采用分阶段执行机制。首先确认个体身份,随后读取运行配置,再加载赋值清单,检查赋值版本和内容完整性,最后建立运行引擎所需的基础资源。任何必要步骤失败,都不能直接将个体标记为可以正常运行。

    例如,个体身份检查通过,但赋值清单缺失,说明运行主体已经存在,却没有获得完整的知识能力配置。此时可以将个体状态标记为initialization_failed或assignment_missing,而不能继续进入任务处理过程。

    同样,如果赋值清单存在,但其中某个必要方法实现文件缺失,或者知识结构引用的版本与实际文件不一致,也应当停止相关能力的初始化。对于存在多个独立能力的个体,可以根据能力依赖关系判断是否允许部分初始化,但不能把不完整能力标记为完整能力。

    初始化程序还需要考虑重复启动。个体运行进程可能因为设备重启、程序异常或人工维护而重新启动。重复启动时,不能无条件创建新的运行上下文并覆盖原有任务状态。初始化程序应当读取上次保存的运行状态,检查是否存在未完成任务、运行检查点或需要恢复的对象状态,再决定执行全新初始化还是运行恢复。

    个体初始化完成后,应当形成明确的初始化结果。例如:

    {
        "individual_id": "individual_001",
        "runtime_version": "1.0.0",
        "assignment_version": "2.0.0",
        "initialization_status": "success",
        "structure_loaded": true,
        "capability_loaded": true,
        "method_registry_ready": true,
        "resource_status": "available"
    }

    该结果表示个体已经完成基础运行初始化,但不代表它已经具备执行所有任务的条件。具体任务能否运行,还需要根据任务内容进行能力匹配、运行条件检查和执行约束验证。

    初始化程序的最终职责是将个体从未启动状态转换为具有明确运行基础的初始化完成状态,并将运行引擎所需的对象、结构、能力、方法和资源管理对象准备就绪。

    第三节 个体结构加载与运行上下文

    个体运行环境建立并完成初始化之后,需要将赋值清单中的知识结构加载到运行引擎中。结构加载是个体运行过程中非常重要的基础环节。个体获得的知识能力并不是一组互不相关的数据文件,而是由对象定义、属性定义、对象关系、状态条件、能力关联和方法组成的结构化内容。运行引擎必须按照结构之间的关联关系完成加载,才能形成能够被后续运行过程使用的知识结构。

    结构加载不能只根据文件名称读取内容,也不能只把JSON数据解析成数组就认定结构加载完成。运行引擎需要根据赋值清单确定当前个体应当加载哪些结构,检查结构版本及其依赖关系,建立对象、属性、关系和状态之间的关联,并将结构定义注册到运行时结构管理对象中。

    例如,某个物料搬运个体获得了物料对象结构、仓储位置结构、路径关系结构和搬运状态结构。运行引擎需要将这些结构分别加载,再根据结构定义中的关联关系建立物料与位置、位置与路径、物料状态与搬运条件之间的联系。

    如果只加载物料对象定义,却没有加载它依赖的属性定义和状态定义,那么个体就无法完整识别物料的实际状态。如果加载了路径对象,却没有建立路径节点之间的关系,也无法形成有效的路径分析基础。

    因此,结构加载应当按照结构依赖关系进行,而不是单纯按照文件顺序加载。后台在知识能力构建阶段已经形成结构关联和依赖定义,个体运行引擎需要依据这些信息完成本地结构解析和关联注册。

    工程上可以将结构加载程序组织为:

    engine/
    └── Structure/
        ├── StructureLoader.php             # 结构加载统一入口
        ├── StructureDefinitionReader.php   # 读取结构定义数据
        ├── ObjectDefinitionLoader.php      # 加载对象定义
        ├── AttributeDefinitionLoader.php   # 加载属性定义
        ├── RelationDefinitionLoader.php    # 加载对象关系定义
        ├── StateDefinitionLoader.php       # 加载对象状态定义
        ├── StructureDependencyResolver.php # 解析结构之间的依赖关系
        ├── RuntimeStructureRegistry.php    # 注册已加载的运行时结构
        └── StructureLoadResult.php         # 保存结构加载结果

    StructureLoader统一组织结构加载过程。StructureDefinitionReader读取后台交付的结构定义。对象、属性、关系和状态加载程序分别处理相应的数据内容。StructureDependencyResolver根据结构依赖关系确定加载顺序,并检查是否存在缺失引用。RuntimeStructureRegistry保存已经完成加载和验证的运行时结构,供后续对象识别和能力调用使用。StructureLoadResult记录加载数量、版本和异常情况。

    结构加载完成后,运行引擎还需要建立实际对象实例与结构定义之间的关系。结构定义描述对象的组成和处理规则,实际对象实例则保存运行过程中获取的具体对象及其属性值和状态。两者必须分离保存。

    例如,物料对象结构可以定义物料编号、重量、尺寸、类别和当前状态等属性,但实际运行过程中识别到的每一个物料都是独立对象实例。运行引擎根据已加载的结构定义检查实际对象信息,并将符合定义的数据组织为对象实例。

    {
        "object_instance_id": "material_0001",
        "structure_id": "structure_material",
        "attributes": {
            "material_code": "M001",
            "weight": 12.5,
            "category": "standard"
        },
        "state": "identified"
    }

    这里的对象实例引用structure_material,并不意味着实例自身包含完整的结构定义。运行引擎通过结构注册表找到对应定义,再根据定义解释对象实例的属性和值。

    结构加载只是个体运行的基础,还需要建立运行上下文。运行上下文是个体在某一具体运行阶段用于组织任务、对象、状态、能力和执行条件的数据环境。它将当前任务与已经加载的知识结构关联起来,使运行引擎能够在不同任务之间建立清晰的处理边界。

    例如,同一个个体在一天内可能先执行物料识别任务,再执行搬运任务。两个任务可以使用部分相同的知识结构,但涉及的对象实例、任务条件、执行状态和处理结果并不相同。若不建立独立的运行上下文,前一个任务的对象状态和执行结果可能错误地影响后一个任务。

    运行上下文至少需要关联当前个体身份、当前任务、赋值版本、所使用的知识结构版本、任务对象、对象状态、已匹配能力、执行规则和运行阶段。对于需要恢复的任务,还需要保存上下文检查点,使个体能够在异常恢复后继续处理。

    运行上下文可以采用如下数据模型:

    {
        "context_id": "context_001",
        "individual_id": "individual_001",
        "task_id": "task_001",
        "assignment_version": "2.0.0",
        "runtime_status": "processing",
        "objects": [
            "material_0001",
            "location_0005"
        ],
        "capabilities": [
            "cap_object_recognition",
            "cap_path_analysis"
        ],
        "current_stage": "object_analysis",
        "created_at": "2026-11-15 10:00:00"
    }

    运行上下文由运行引擎创建和维护,不应由每个方法自行随意生成一套任务状态。这样,多个方法在同一任务中执行时,可以访问同一任务上下文,并按照统一的状态变化机制更新处理结果。

    程序组织可以采用:

    engine/
    └── Context/
        ├── RuntimeContext.php              # 个体运行上下文对象
        ├── ContextManager.php              # 创建、读取和释放运行上下文
        ├── TaskContext.php                 # 保存当前任务相关数据
        ├── ObjectContext.php               # 管理任务涉及的对象实例
        ├── CapabilityContext.php           # 管理当前任务使用的知识能力
        ├── ExecutionContext.php            # 保存方法执行过程与执行条件
        ├── ContextSnapshot.php             # 生成上下文检查点
        └── ContextRepository.php           # 持久化和恢复运行上下文

    RuntimeContext表示当前运行过程的整体上下文。ContextManager负责创建、切换和释放上下文。TaskContext保存任务本身的信息和处理阶段。ObjectContext管理任务涉及的实际对象。CapabilityContext记录当前任务已经匹配和允许调用的能力。ExecutionContext保存方法调用所需的执行条件和过程状态。ContextSnapshot负责生成恢复检查点。ContextRepository负责将需要保留的上下文数据写入本地存储。

    运行上下文与知识结构之间需要保持版本一致性。一个任务开始运行时,应当明确使用哪个赋值版本和哪些结构版本。如果任务执行期间后台发布了新的知识能力版本,个体不能在没有控制的情况下自动将部分结构切换为新版本,否则同一个任务可能在不同阶段使用不一致的知识定义。

    对于正在运行的任务,应当保持当前任务上下文引用的版本稳定。新版本可以进入候选加载状态,等待当前任务结束或达到允许切换的安全条件后,再创建新的运行上下文。若工程确实需要在任务中途更新知识结构,则必须明确允许更新的结构范围,并验证新旧结构之间的兼容关系。

    运行上下文还承担任务状态连续性的管理职责。当个体遇到临时故障、进程退出或通信中断时,可以根据保存的上下文恢复任务处理状态。但恢复并不意味着无条件重复执行上一次方法。对于涉及实际设备操作的方法,运行引擎还需要检查该操作是否已经执行、设备当前状态是否发生变化,以及重复执行是否会造成不良后果。

    因此,结构加载解决的是个体如何获得并组织知识结构,运行上下文解决的是个体如何在具体任务中使用这些知识结构。二者结合,才能为个体后续的对象识别、知识能力调用、认知判断和方法执行提供统一的运行基础。

    第四节 个体运行引擎的程序组织

    个体运行引擎是个体自主运行过程的核心程序组织部分。它将已经初始化的运行环境、已加载的知识结构、知识能力、方法和执行规则组织为连续的处理过程。

    个体运行引擎不负责重新构建后台的知识能力定义,也不负责重新设计整个任务组织。它接收个体运行环境中的任务信息,根据当前任务上下文匹配已经赋予的知识能力,再按照能力定义和执行规则调用对应方法,完成个体自身职责范围内的处理。

    运行引擎需要建立统一的运行调度机制。任务进入个体后,运行引擎首先确认任务是否属于当前个体的职责范围,再检查当前赋值版本是否满足任务要求,随后创建任务上下文,组织对象信息处理和知识能力调用。对于需要形成判断和执行动作的任务,还需要将处理结果交给后续认知、决策和方法执行程序。

    运行引擎不能把所有知识处理过程写成固定的业务流程。个体获得的知识能力可能因任务不同而变化,运行引擎应当根据能力定义和结构关系进行组织,使不同个体可以使用同一运行引擎运行不同的知识能力。

    例如,物料识别个体和搬运个体可以使用相同的基础运行引擎,但它们的任务处理过程不同。物料识别个体重点调用对象识别、属性匹配和状态判断能力;搬运个体则需要调用目标确认、路径分析、执行条件判断和设备控制方法。运行引擎提供统一的运行组织机制,具体处理内容由当前个体被赋予的知识能力决定。

    从程序结构上,可以将运行引擎分为核心调度、任务接收、能力匹配、结构访问、方法调用、规则检查和结果处理等相互关联的程序部分。

    engine/
    ├── Kernel/
    │   ├── RuntimeKernel.php                # 个体运行引擎核心调度程序
    │   ├── RuntimeScheduler.php             # 管理运行任务的调度顺序
    │   ├── RuntimeDispatcher.php             # 将任务分发给相应处理程序
    │   └── RuntimeEventManager.php           # 管理运行事件及事件传递
    │
    ├── Task/
    │   ├── TaskReceiver.php                  # 接收个体运行任务
    │   ├── TaskValidator.php                 # 检查任务结构和适用条件
    │   ├── TaskProcessor.php                 # 组织任务处理过程
    │   └── TaskResult.php                    # 保存任务处理结果
    │
    ├── Capability/
    │   ├── CapabilityMatcher.php             # 匹配当前任务所需知识能力
    │   ├── CapabilityLoader.php              # 加载已赋值知识能力
    │   ├── CapabilityInvoker.php             # 调用知识能力处理程序
    │   └── CapabilityExecutionResult.php     # 保存能力调用结果
    │
    ├── Method/
    │   ├── MethodRegistry.php                # 管理个体可调用的方法
    │   ├── MethodDispatcher.php              # 分发方法调用
    │   └── MethodExecutionManager.php        # 管理方法执行过程
    │
    ├── Rule/
    │   ├── ExecutionRuleLoader.php           # 加载个体执行规则
    │   └── ExecutionRuleChecker.php          # 检查方法执行约束
    │
    └── Result/
        ├── RuntimeResultBuilder.php           # 组织运行结果
        └── RuntimeResultRecorder.php          # 保存运行结果和处理记录

    上述程序组织将运行引擎中的不同职责分开。核心调度程序负责协调运行过程,任务程序负责接收和处理任务,能力程序负责将任务与已赋值知识能力建立关联,方法程序负责具体方法的调用,规则程序负责执行条件检查,结果程序负责形成和保存运行结果。

    运行引擎的核心调度程序不应直接包含物料搬运、设备检测或无人机飞行等具体业务逻辑。它只需要依据当前个体的能力定义和任务上下文组织调用。具体方法由能力定义所关联的程序提供,实际设备操作则由相应设备接口完成。

    运行引擎可以通过统一的核心调度入口组织执行:

    <?php
    
    class RuntimeKernel
    {
        private $taskValidator;
        private $contextManager;
        private $capabilityMatcher;
        private $capabilityInvoker;
        private $ruleChecker;
        private $resultBuilder;
    
        public function __construct(
            $taskValidator,
            $contextManager,
            $capabilityMatcher,
            $capabilityInvoker,
            $ruleChecker,
            $resultBuilder
        ) {
            $this->taskValidator = $taskValidator;
            $this->contextManager = $contextManager;
            $this->capabilityMatcher = $capabilityMatcher;
            $this->capabilityInvoker = $capabilityInvoker;
            $this->ruleChecker = $ruleChecker;
            $this->resultBuilder = $resultBuilder;
        }
    
        public function run($task, $individual)
        {
            // 检查任务是否适用于当前个体
            $taskCheck = $this->taskValidator->validate(
                $task,
                $individual
            );
    
            if (!$taskCheck['passed']) {
                return $this->resultBuilder->failure(
                    'task_not_supported',
                    $taskCheck
                );
            }
    
            // 建立本次任务的运行上下文
            $context = $this->contextManager->create(
                $task,
                $individual
            );
    
            // 匹配当前任务需要的知识能力
            $capabilityResult = $this->capabilityMatcher->match(
                $task,
                $individual,
                $context
            );
    
            if (!$capabilityResult['matched']) {
                return $this->resultBuilder->failure(
                    'capability_not_satisfied',
                    $capabilityResult
                );
            }
    
            // 检查执行规则
            $ruleResult = $this->ruleChecker->check(
                $task,
                $capabilityResult,
                $context
            );
    
            if (!$ruleResult['passed']) {
                return $this->resultBuilder->failure(
                    'execution_rule_rejected',
                    $ruleResult
                );
            }
    
            // 调用对应知识能力
            $executionResult = $this->capabilityInvoker->invoke(
                $capabilityResult,
                $context
            );
    
            return $this->resultBuilder->build(
                $task,
                $executionResult,
                $context
            );
        }
    }

    这段程序表达了运行引擎的主要调度关系。实际工程中,任务验证还需要检查个体当前运行状态、任务优先级和运行资源;能力匹配需要检查赋值版本和能力依赖;规则检查需要根据具体任务及方法执行条件进行判断;能力调用则需要在运行上下文中组织多个方法的执行过程。

    特别需要注意,知识能力调用与方法执行并不是同一件事。能力是由知识结构和方法组合形成的问题处理能力,方法是其中具体的操作。运行引擎根据任务匹配能力后,还需要依据能力定义中的方法关系组织具体操作,不能将能力名称直接作为可执行程序调用。

    例如,某个搬运能力可能由目标位置匹配、路线计算、载荷条件判断和移动方法组成。运行引擎需要先确认当前任务满足能力调用条件,再按照能力结构中的关系组织这些方法。若目标位置尚未确认,则不能越过必要判断直接执行移动方法。

    因此,运行引擎需要建立方法注册与分发机制。每个方法都应当具有明确的方法标识、输入结构、输出结构、依赖资源和执行约束。方法注册表负责记录方法与实现程序之间的映射,方法分发程序根据能力定义中的方法标识找到对应实现,并将运行上下文和必要参数传入。

    方法执行接口可以设计为:

    <?php
    
    interface RuntimeMethodInterface
    {
        public function execute($context, $parameters);
    
        public function getMethodId();
    }

    不同方法按照统一接口实现,但其内部操作内容可以不同。结构比较方法负责比较对象结构,计算方法负责执行指定计算,判断方法负责依据条件形成判断,匹配方法负责匹配结构和状态,设备控制方法则通过设备接口执行允许的操作。

    对于设备控制类方法,运行引擎还需要检查设备资源是否可用、操作是否处于允许范围,以及当前运行规则是否允许执行。方法注册成功并不意味着方法可以在任何条件下调用。

    运行引擎还需要处理方法执行结果。一个方法执行后可能返回成功、失败、条件不满足、资源不可用或需要进一步判断等结果。运行引擎应当将这些结果写入当前运行上下文,再依据能力定义决定是否继续后续处理、重新判断、暂停任务或形成异常结果。

    对于一个任务中需要调用多个能力的情况,运行引擎还应当管理能力之间的调用关系。能力之间可能存在先后顺序、条件依赖和结果传递。后台赋予个体的知识能力定义应当包含这些关系,个体运行引擎负责按照定义执行,而不是在程序中固定写死所有处理顺序。

    在多任务运行场景中,运行引擎还需要区分任务调度和任务执行。调度程序负责决定哪些任务可以进入处理阶段,执行程序负责完成具体能力调用。若个体只有一个执行资源,可以按照任务优先级和运行条件顺序处理;若个体支持多个独立运行单元,则可以在明确资源隔离和对象访问边界的前提下并行处理。

    对于可能相互影响的任务,不能仅因为运行资源充足就允许并行执行。例如,两个任务同时控制同一设备执行互相冲突的动作,即使程序层面可以并行运行,也不意味着实际设备可以安全执行。因此,运行引擎的调度过程必须结合对象关系、资源占用和执行规则进行判断。

    由此,个体运行引擎形成了从任务接收、任务验证、上下文建立、知识能力匹配、规则检查、方法调用到结果处理的完整运行组织机制。它将后台赋予的知识能力转化为个体能够自主使用的运行过程,同时保持与智能控制后台的职责边界。

    第五节 个体运行状态与资源管理

    个体运行引擎需要持续掌握自身的运行状态和资源使用情况。运行状态决定个体当前能够接受什么任务、是否允许调用某项能力,以及是否可以进行赋值版本切换。资源管理则决定个体是否具备完成当前任务所需的处理能力、存储空间、设备接口和执行资源。

    个体运行状态不能只使用简单的在线和离线进行描述。一个个体即使能够正常启动,也可能尚未完成初始化;即使已经完成初始化,也可能尚未加载知识能力;即使知识能力已经加载,也可能因为设备状态异常或资源不足而无法执行任务。

    因此,个体运行状态需要与其运行过程相对应。可以采用以下状态模型:

    created
        个体运行环境已经建立
    
    initializing
        正在执行运行初始化
    
    initialized
        基础运行环境初始化完成
    
    loading
        正在加载知识结构与能力
    
    ready
        已完成必要加载和验证,可以接受适用任务
    
    running
        正在执行任务
    
    waiting
        等待任务、条件或外部资源
    
    suspended
        当前运行过程已暂停
    
    maintenance
        进入维护状态
    
    error
        运行过程中出现异常
    
    stopped
        运行程序已经停止

    这些状态属于个体运行状态,不应与第二十一章定义的个体生命周期状态、第二十四章定义的部署状态以及第二十五章定义的赋值关系状态混用。个体生命周期描述个体从建立到退出的长期过程,部署状态描述知识能力交付和部署过程,赋值状态描述个体与能力之间的关联是否有效,而运行状态描述个体当前实际运行情况。

    例如,个体生命周期可能处于正常使用阶段,赋值关系也处于有效状态,但个体运行状态因为设备异常而进入suspended。此时,个体并没有被撤销,也没有失去已经获得的知识能力,只是暂时不能继续执行任务。

    运行状态需要由运行引擎根据实际事件进行转换,而不是由多个程序随意修改。可以建立统一的状态管理程序:

    engine/
    └── State/
        ├── RuntimeStateManager.php       # 统一管理个体运行状态
        ├── RuntimeStateMachine.php       # 管理运行状态转换规则
        ├── RuntimeStateRepository.php    # 保存个体运行状态
        ├── RuntimeEventHandler.php       # 根据运行事件处理状态变化
        └── RuntimeStateValidator.php     # 检查状态转换是否合法

    RuntimeStateManager负责对外提供状态查询和状态变更入口。RuntimeStateMachine定义允许的状态转换关系。RuntimeStateRepository负责持久化当前状态和历史记录。RuntimeEventHandler接收初始化完成、任务开始、任务结束、资源不足和运行异常等事件,并根据事件调用状态转换程序。RuntimeStateValidator检查状态转换是否符合当前运行条件。

    例如,个体处于ready状态时可以接受适用任务,任务开始后进入running。任务正常结束后,如果没有其他任务等待执行,则可以回到ready;如果任务尚未满足执行条件,则可以进入waiting;如果运行过程出现需要人工处理的异常,则可以进入suspended或error。

    状态转换需要有明确条件。例如,个体不能在尚未完成初始化时直接进入ready,也不能在实际任务仍处于执行状态时,仅通过修改数据库字段将其标记为stopped。对于实体设备,状态转换还需要结合设备控制器返回的真实状态,避免后台记录与设备实际运行情况不一致。

    个体状态数据可以采用以下结构保存:

    {
        "individual_id": "individual_001",
        "runtime_status": "running",
        "previous_status": "ready",
        "assignment_version": "2.0.0",
        "current_task_id": "task_001",
        "current_context_id": "context_001",
        "resource_status": "normal",
        "last_state_change": "2026-11-15 10:30:00"
    }

    该结构保存当前运行状态、上一个状态、赋值版本、正在处理的任务和运行上下文标识。实际工程中还需要保存状态变化原因、触发事件、执行程序和必要的状态检查结果,以便后台追溯个体运行过程。

    资源管理则需要从运行引擎自身资源和实际任务资源两个层面进行设计。

    运行引擎自身资源包括处理器时间、内存、存储空间、缓存、运行线程或进程等。实际任务资源则包括任务所涉及的对象、设备接口、传感器数据源、执行机构、网络接口和其他可访问资源。两者虽然有关联,但不能混为一谈。

    例如,某个个体可能具有足够的内存和处理能力,却因为设备控制接口被其他任务占用而无法执行新的动作。另一个个体可能设备资源正常,但本地存储空间不足,无法保存必要的任务数据和运行检查点。运行引擎必须同时检查这两类资源,才能判断个体是否具备继续执行任务的条件。

    可以建立如下程序组织:

    engine/
    └── Resource/
        ├── RuntimeResourceManager.php      # 统一管理个体运行资源
        ├── ResourceMonitor.php             # 监测本地运行资源状态
        ├── MemoryResourceManager.php       # 管理运行内存使用
        ├── StorageResourceManager.php      # 管理本地存储空间
        ├── DeviceResourceManager.php       # 管理设备及其控制资源
        ├── ResourceAllocator.php           # 为任务分配可用资源
        ├── ResourceLockManager.php         # 管理独占资源及并发访问
        └── ResourceReleaseManager.php      # 释放已经使用的资源

    RuntimeResourceManager负责组织资源检查和分配。ResourceMonitor持续获取本地资源状态。MemoryResourceManager和StorageResourceManager分别管理内存和存储。DeviceResourceManager负责管理个体可以访问的设备资源。ResourceAllocator根据任务需求分配资源。ResourceLockManager用于防止多个任务同时对同一独占资源进行冲突操作。ResourceReleaseManager负责在任务结束、暂停或异常处理时释放不再使用的资源。

    资源分配需要与任务上下文关联。一个任务开始执行前,运行引擎应当根据任务需要申请必要资源,并将资源占用信息写入运行上下文。任务结束后,按照资源使用规则释放相关资源。对于需要持续占用的设备资源,应当在执行期间保持明确的占用状态,避免其他任务未经许可重复使用。

    资源管理不能仅采用简单的资源数量判断。例如,两个任务都需要使用同一个机械臂,即使处理器和内存资源充足,也不能同时允许两个任务控制该机械臂执行互相冲突的动作。运行引擎需要根据资源类型建立不同的分配规则。

    对于可以共享的资源,可以允许多个任务同时读取;对于只能由一个任务使用的资源,应当建立独占关系;对于存在执行顺序要求的资源,则需要根据任务条件进行排队和调度。

    资源分配结果可以保存为:

    {
        "resource_allocation_id": "resource_001",
        "individual_id": "individual_001",
        "task_id": "task_001",
        "resources": [
            {
                "resource_id": "device_controller_01",
                "resource_type": "device",
                "access_mode": "exclusive",
                "status": "allocated"
            },
            {
                "resource_id": "local_storage",
                "resource_type": "storage",
                "access_mode": "shared",
                "status": "allocated"
            }
        ],
        "allocation_status": "active"
    }

    这份数据描述任务运行期间所获得的资源及其访问方式。实际工程中还需要记录资源申请时间、释放时间、占用期限、资源使用结果和异常原因。

    运行状态与资源管理之间需要形成联动关系。当运行引擎发现内存不足、存储异常或必要设备接口不可用时,应当根据任务类型和执行约束决定是否暂停当前任务。对于允许等待资源恢复的任务,可以进入waiting;对于需要立即停止的任务,应当执行相应的安全处理程序;对于已经无法恢复的任务,则需要记录失败状态,并将问题反馈给后台。

    当个体处于通信中断状态时,资源管理仍然需要在本地继续工作。通信不是个体自主运行的必要条件。只要个体已经获得当前任务所需的知识结构、方法、规则和本地资源,就可以依据自身运行引擎继续执行允许独立完成的任务。

    无通信运行期间,个体应当保存必要的运行状态、任务结果和资源使用记录。若任务需要后台提供新的知识能力、执行授权或其他必要信息,而本地尚未获得这些内容,则不能将缺少的能力当作已经具备。个体只能在已赋值的知识能力和允许的自主运行范围内继续工作。

    当通信恢复后,个体可以按照既定通信机制向后台提交运行状态、任务结果、异常记录和资源变化信息。后台根据这些反馈分析个体当前能力是否仍然满足任务需求,是否需要增加知识能力、调整赋值版本或重新组织个体职能。

    对于支持通信运行和无通信自主运行两种模式的个体,运行引擎应当将本地运行状态与后台同步状态分开管理。通信中断不能自动等同于个体停止运行,后台暂时无法获取个体状态也不能直接认定个体发生故障。个体应当根据本地实际运行结果维护自身状态,并在通信恢复后进行状态同步。

    个体运行资源和状态数据还需要形成持久化机制。对于普通软件个体,可以采用数据库保存任务状态、运行上下文和资源占用记录;对于资源受限设备,可以使用本地轻量级数据库或结构化文件保存关键状态。运行引擎还应当定期生成必要的运行检查点,避免进程异常退出后丢失全部任务信息。

    运行检查点不能只保存当前任务名称,还需要保存当前赋值版本、运行上下文、对象状态、已完成的处理阶段和必要的资源状态。对于涉及设备执行的任务,还应当保存实际执行结果,以便恢复时判断哪些操作已经完成,避免不加判断地重复执行。

    最终,个体运行状态管理和资源管理共同形成运行引擎的持续运行基础。运行状态决定个体当前处于什么运行阶段,资源管理决定个体是否具备继续执行任务的条件,运行上下文则将任务、能力和资源联系起来。三者结合,使个体能够在不同运行条件下保持明确的运行边界。

    本章建立的个体运行环境与运行引擎,是后续个体信息获取、对象识别、知识能力调用和自主判断的基础。个体在完成环境建立、运行初始化、结构加载和上下文创建后,便具备了进入具体任务处理过程的工程条件。下一阶段需要进一步研究个体如何从自身运行环境和外部实际对象中获取信息,如何将获取的信息组织为可识别的对象结构,以及如何依据已经赋予的知识能力完成对象识别与信息处理。

Leave a Reply

Your email address will not be published. Required fields are marked *

客服咨询
● 欢迎咨询与合作
您好!欢迎咨询。 我可以帮助您了解人工智能技术研发、智能软件系统开发、网站建设、搜索优化及项目定制等相关信息。 请问有什么可以帮您?
免费申请
请填写以下信息,方便我们进一步沟通。
欢迎咨询 AI 系统开发、网站建设、搜索优化、项目定制合作
电话:15089196448
邮箱:1602401899@qq.com
地址:陕西省渭南市
服务时间:周一至周五 09:00 - 18:00 | 7×24小时技术值守