CN109960570A - 一种多模块调度方法、装置和系统 - Google Patents

Abstract

本发明公开一种多模块调度方法、装置和系统，以解决现有多模块调度技术中存在的技术问题计算模块的输入数据存在不一致、计算模块间数据传输时延显著中的至少之一。该方法包括：主进程读取预存的配置文件，配置文件中保存有一个有向计算图；主进程在当前计算周期中，初始化节点和连接边的状态；根据有向计算图中的计算方向以及节点的状态确定待调用节点，待调用节点包括节点的多个输入边均为完成状态的节点；向待调用节点对应的从进程中的计算模块发送RPC调用请求以执行该计算模块；在收到应答响应后，更新该节点的状态和该节点的输出边的状态；在确定全部节点的状态更新结束后，进行下一个计算周期的处理。

Description

一种多模块调度方法、装置和系统

技术领域

本发明涉及计算机科学领域，特别涉及一种多模块调度方法、装置及系统。

背景技术

目前在深度学习领域中，在一个学习任务中会设置许多学习模块。现有技术中通常采用如下的技术方案实现多模块调度：将每一个模块封装成一个进程，模块之间依靠进程之间的socket通信机制，通过发布和订阅消息来获取需要的输入数据和发送输出数据。该方案的优点在于，各进程可以实现跨机通信，每个模块所在的进程可以分布在不同机器间，无需改变系统架构。

以自动驾驶技术中的深度学习任务为例，如图1所示，单机1上运行如下模块：摄像头1、车辆检测1、车辆追踪1、摄像头2、车辆检测2、车辆追踪2、融合1，单机2上运行如下模块：摄像头3、车辆检测3、车辆追踪3和分割5，这些模块均被封装为单独的进程，车辆检测1获取摄像头 1输出的数据第一帧图像P11，对数据P11进行处理后，输出数据P11’，车辆跟踪1获取摄像头1输出的数据P11和车辆检测1输出的数据P11’，对数据P11和P11’进行处理，得到数据G11。同理，车辆检测2和车辆追踪2，以及车辆检测3和车辆追踪3具有与上述相类似的处理，并且分别得到数据G21和G31。分割3获取摄像头3输出的数据P31，并对数据P31进行处理，得到数据Q31。融合分别获取来自车辆追踪1、车辆追踪2、车辆追踪3和分割3的数据P11、P21、P31和Q31，并对数据进行处理得到结果，并将该结果输出给控制器。图1中各进程之间的通信机制为socket机制，通过发布和订阅消息来获取进程所需要的输入数据和输出数据。

但是在上述的多模块调度方案中，存在至少两个技术问题：

第一，计算模块的输入数据存在不一致。如图1中的进程车辆跟踪1 需要来自进程摄像头1的输出数据P1和来自进程车辆检测1的输出数据 P1’。但是由于系统使用消息机制传递信息时存在延时，当车辆检测1将输出数据P1’发送到车辆跟踪1时，车辆跟踪1接收到的来自摄像头1的数据是第二帧图像P12、而不是第一帧图像P11，从而导致进程车辆跟踪1的计算错误。当模块数目增大时，这种不一致性的问题更加显著，并且会扩大计算错误。

第二，计算模块间数据传输时延显著。由于将各个计算模块都封装为单独的进程，进程之间通过通信机制进行数据的传输，当进程之间传递大量的图片信息时，该通信需要进行大量的序列化、反序列化、压缩、解压缩等操作，这样极大地增加了通信开销，增大了处理时长。经过测试，在同一台机器内，进程之间发送和接收一张图片的延时在5毫秒(ms)左右，在两台机器之间进行进程之间的传输，时延高达40ms。这样高的时延极大地增加了系统整体的延时，大幅度地降低了系统的吞吐量。

发明内容

鉴于上述问题，本发明提供一种多模块调度方法、装置和系统，以解决现有多模块调度技术中存在的技术问题计算模块的输入数据存在不一致、计算模块间数据传输时延显著吞吐量低中的至少之一。

根据本申请的一个方面，提供了一种多模块调度方法，包括：

主进程读取预存的配置文件，配置文件中保存有一个有向计算图；其中，有向计算图与一个计算任务相对应，计算任务包括多个从进程，每个从进程包括按照计算方向组合的多个计算模块；有向计算图中包括多个节点，每个节点对应一个从进程中的一个计算模块，节点之间具有连接边，进入节点的连接边为输入边，离开节点的连接边为输出边；

在当前计算周期中，主进程初始化节点和连接边的状态；

根据有向计算图的计算方向以及节点的状态确定待调用节点，其中，待调用节点包括节点的多个输入边均为完成状态的节点；

向待调用节点对应的从进程中的计算模块发送远程过程调用(RPC)的调用请求以执行该计算模块；

在收到针对调用请求的应答响应后，更新该节点的状态和该节点的输出边的状态；

在确定有向计算图的全部节点的状态更新结束后，进行下一个计算周期的处理。

根据本申请的另一个方面，提供了一种多模块调度方法，包括：

在当前计算周期中，从进程中的一个计算模块接收来自主进程的远程过程调用(RPC)的调用请求；其中，从进程中包括根据计算方向组合的多个计算模块；对于具有多个输入数据的计算模块，调用请求是主进程在确定计算模块的多个输入数据都已就绪的情况下发出的；

该计算模块响应于调用请求执行处理；

在处理执行完成后，计算模块向主进程反馈应答响应。

根据本申请的另一个方面，提供了一种多模块调度装置，包括：

读取模块，用于读取预存的配置文件，配置文件中保存有一个有向计算图；其中，有向计算图与一个计算任务相对应，计算任务包括多个从进程，每个从进程包括按照计算方向组合的多个计算模块；有向计算图中包括多个节点，每个节点对应一个从进程中的一个计算模块，节点之间具有连接边，进入节点的连接边为输入边，离开节点的连接边为输出边；

执行模块，用于在当前计算周期中，初始化节点和连接边的状态；根据有向计算图的计算方向以及节点的状态确定待调用节点，其中，待调用节点包括节点的多个输入边均为完成状态的节点；向待调用的节点对应的从进程中的计算模块发送远程过程调用(RPC)的调用请求以执行该计算模块；在收到针对调用请求的应答响应后，更新该节点的状态和该节点的输出边的状态；在确定有向计算图的全部节点的状态更新结束后，进行下一个计算周期的处理。

根据本申请的另一个方面，提供了一种多模块调度装置，该多模块调度装置应用在一个从进程中，从进程中包括按照计算方向组合的多个多模块调度装置，该装置包括：

接收模块，用于在当前计算周期中，接收来自主进程的远程过程调用(RPC)的调用请求；对于具有多个输入数据的多模块调度装置，调用请求是主进程在确定多模块调度装置的多个输入数据都已就绪的情况下发出的；

执行模块，用于响应于调用请求执行处理；

反馈模块，用于在执行模块执行完处理后，计算模块向主进程反馈应答响应。

根据本申请的另一个方面，提供了一种多模块调度装置，其特征在于，包括：一个处理器和至少一个存储器，至少一个存储器中存储有至少一条机器可执行指令，处理器执行至少一条机器可执行指令以实现：

读取预存的配置文件，配置文件中保存有一个有向计算图；其中，有向计算图与一个计算任务相对应，计算任务包括多个从进程，每个从进程包括按照计算方向组合的多个计算模块；有向计算图中包括多个节点，每个节点对应一个从进程中的一个计算模块，节点之间具有连接边，进入节点的连接边为输入边，离开节点的连接边为输出边；

在当前计算周期中，主进程初始化节点和连接边的状态；

根据有向计算图的计算方向以及节点的状态确定待调用节点，其中，待调用节点包括节点的多个输入边均为完成状态的节点；

向待调用节点对应的从进程中的计算模块发送远程过程调用(RPC)的调用请求以执行该计算模块；

在收到针对调用请求的应答响应后，更新该节点的状态和该节点的输出边的状态；

在确定有向计算图的全部节点的状态更新结束后，进行下一个计算周期的处理。

根据本申请的另一个方面，提供了一种多模块调度装置，包括一个处理器和至少一个存储器，至少一个存储器中存储有至少一条机器可执行指令，处理器执行至少一条机器可执行指令以实现：

在当前计算周期中，收来自主进程的远程过程调用(RPC)的调用请求；对于具有多个输入数据的多模块调度装置，调用请求是主进程在确定多模块调度装置的多个输入数据都已就绪的情况下发出的；

响应于调用请求执行处理；

在处理执行完成后向主进程反馈应答响应。

根据本申请的另一个方面，提供了一种多模块调度系统，包括：主进程和多个从进程；其中，每个从进程包括按照计算方向组合的多个计算模块；

主进程用于读取预存的配置文件，配置文件中保存有一个有向计算图；其中，有向计算图与一个计算任务相对应，计算任务包括多个从进程，每个从进程包括按照计算方向组合的多个计算模块；有向计算图中包括多个节点，每个节点对应一个从进程中的一个计算模块，节点之间具有连接边，进入节点的连接边为输入边，离开节点的连接边为输出边；在当前计算周期中，主进程初始化节点和连接边的状态；根据有向计算图的计算方向以及节点的状态确定待调用节点，其中，待调用节点包括节点的多个输入边均为完成状态的节点；向待调用节点对应的从进程中的计算模块发送远程过程调用(RPC)的调用请求以执行该计算模块；在收到针对调用请求的应答响应后，更新该节点的状态和该节点的输出边的状态；在确定有向计算图的全部节点的状态更新结束后，进行下一个计算周期的处理；

从进程中的一个计算模块接收来自主进程的RPC的调用请求；该计算模块响应于调用请求执行处理；在处理执行完成后，计算模块向主进程反馈应答响应。

根据本申请实施例提供的技术方案，根据本申请实施例提供的技术方案，主进程根据有向计算图来控制从进程中所有计算模块的计算逻辑，即主进程通过RPC来控制计算模块的执行，并且根据模块执行的情况来维护与模块对应的节点的状态，以及节点的输出的状态；在一个节点的多个输入边的状态均为完成的情况下，才能调用执行与节点对应的计算模块，在收到应答响应的情况下，更新该节点的状态和该节点的输出边的状态，也即，计算模块在一个计算周期中的多个输入数据都完成的情况下，计算模块才会得到调用执行处理，从而能够控制保证计算模块的输入数据的一致性。

附图说明

附图用来提供对本发明的进一步理解，并且构成说明书的一部分，与本发明的实施例一起用于解释本发明，并不构成对本发明的限制。

图1为现有技术中包括多模块的学习任务的架构示意图；

图2为本申请实施例提供了多模块调度系统的结构示意图；

图3a为本申请实施例提供的一种多模块调度方法的流程图；

图3b为与图2中从进程对应的有向计算图；

图4为本申请提供的另一种多模块调度方法的处理流程图；

图5a为本申请实施例提供的一种多模块调度装置的结构框图；

图5b为本申请实施例提供的一种多模块调度装置的另一种结构框图；

图6为本申请实施例提供的一种多模块调度装置的结构框图；

图7为本申请实施例提供的一种多模块调度装置的结构框图；

图8为本申请实施例提供的一种多模块调度装置的结构框图；

图9a为申请实施例提供的多模块调度系统在应用场景中的结构示意图；

图9b为申请实施例提供的多模块调度系统在应用场景中的另一结构示意 图；

图9c为本申请实施例提供的一个有向计算图的示意图；

图10为存储到控制队列中的有向计算图的示意图；

图11a～图11c为图9b所示系统的处理过程表。

具体实施方式

为了使本技术领域的人员更好地理解本发明中的技术方案，下面将结合本发明实施例中的附图，对本发明实施例中的技术方案进行清楚、完整地描述，显然，所描述的实施例仅仅是本发明一部分实施例，而不是全部的实施例。基于本发明中的实施例，本领域普通技术人员在没有做出创造性劳动前提下所获得的所有其他实施例，都应当属于本发明保护的范围。

针对现有的多模块调度的方案中存在的技术问题：计算模块的输入数据不一致以及计算模块间的通信时延显著吞吐量低，本申请提出了一种多模块调度的技术方案，以解决上述问题中的至少之一。

在本申请提供的技术方案中，设置主进程和从进程，从进程中包括按照计算方向组合的多个计算模块，主进程中预存有一个有向计算图，有向计算图中包括多个节点，每个节点对应于一个从进程中的一个计算模块，节点之间具有连接边，进入节点的连接边为输入边，离开节点的连接边为输出边；主进程根据有向计算图来控制从进程中所有计算模块的计算逻辑，即主进程通过远程过程调用(Remote Process Call，RPC)来控制计算模块的执行，并且根据模块执行的情况来维护与模块对应的节点的状态，以及节点的输出的状态；在一个节点的多个输入边的状态均为完成的情况下，才能调用执行与节点对应的计算模块，在收到应当响应的情况下，更新该节点的状态和该节点的输出边的状态，也即，计算模块在一个计算周期中的多个输入数据都完成的情况下，计算模块才会得到调用进行执行，从而能够控制保证计算模块的输入数据的一致性。

进一步，主进程在控制队列中的空闲存储空间中存入有向计算图，在有向计算图之间，建立相邻的前一个有向计算图中对应串行模块的节点至后一个有向计算图该相同节点的输出边，从而对串行模块进行调度时，需要根据前一个有向计算图中串行模块的执行情况来调度串行模型的执行，而并行模块并不具有这样的约束，从而并行模块能够执行并行处理，提高处理速度。

更进一步地，从进程中包括按照计算方向组合的多个计算模块，从进程中还具有一个对应的共享存储空间，共享存储空间中包括与进程中的每个计算模块相对应的存储空间，计算模块之间不再通过进程之间的通信机制进行数据传输，而是通过进程内共享的存储空间来进行数据的读取和写入，从而能够提高计算模块之间的通信效率，降低通信延时，提高多模块之间整体的通信效率，提高系统吞吐量。

以下结合附图对本申请的技术方案进行详细说明。

图2示出了本申请实施例提供了多模块调度系统的结构示意图，在该系统中包括一个主进程21和多个从进程22，主进程21和从进程22可以被配置在一个终端上，也可以配置在多个终端上，多个从进程22可以分开配置，也可以集中配置。每个从进程都包括按照计算方向组合的多个计算模块。

主进程21用于控制从进程22的计算逻辑，即主进程21用于调用从进程中各个计算模块的执行，并且维护、更新从进程22中各个计算模块的状态。从进程22中的计算模块用于根据主进程的调用，执行相应的处理。

具体地，主进程21用于读取预存的配置文件，配置文件中保存有一个有向计算图；其中，有向计算图与一个计算任务相对应，计算任务包括多个从进程22，每个从进程包括按照计算方向组合的多个计算模块；有向计算图中包括多个节点，每个节点对应一个从进程中的一个计算模块，节点之间具有连接边，进入节点的连接边为输入边，离开节点的连接边为输出边；在当前计算周期中，主进程初始化有向计算图中节点和连接边的状态；根据有向计算图的计算方向以及节点的状态确定待调用节点，其中，待调用节点包括节点的多个输入边均为完成状态的节点；向待调用节点对应的从进程22中的计算模块发送远程过程调用(RPC)的调用请求以执行该计算模块；在收到针对调用请求的应答响应后，更新该节点的状态和该节点的输出边的状态；在确定有向计算图的全部节点的状态更新结束时，进行下一个计算周期的处理。

从进程22中的一个计算模块接收来自主进程的RPC的调用请求；该计算模块响应于调用请求执行处理；在处理执行完成后，计算模块向主进程反馈应答响应。

下面分别说明主进程21和从进程22的工作原理。

图3a示出了本申请实施例提供的一种多模块调度方法的流程图，该方法应用在图2所示的主进程21端。如图3a所示该方法包括如下处理过程：

步骤301、主进程读取预存的配置文件，配置文件中保存有一个有向计算图；其中，有向计算图与一个计算任务相对应，计算任务包括多个从进程，每个从进程包括按照计算方向组合的多个计算模块；图3b中示出了一个示例性的有向计算图，与图2相对应，如图3b所示，有向计算图中包括多个节点，每个节点对应一个从进程中的一个计算模块，节点之间具有连接边，进入节点的连接边为输入边，离开节点的连接边为输出边。

其中，主进程又可以包括主线程和线程池，线程池中包括多个从线程。

步骤302、主进程初始化节点和连接边的状态。

在一个实施例中，从进程中的计算模块包括并行计算模块和串行计算模块；则，

主进程初始化节点和连接边的状态的处理包括：

步骤3021、主线程根据预定时间间隔判断控制队列中是否有空闲存储空间，在判断为是的情况下，也即控制队列中还能够存储有向计算图，处理进行到步骤3022，在判断为否的情况下，也即控制队列中都已存满的情况下，主线程进入等待(wait)状态。

步骤3022、将一个有向计算图存入到一个控制队列的空闲存储空间中。

控制队列可以是先进先出队列，主进程中的主线程将有向计算图存入控制队列的空闲存储空间中时，依次从控制队列的尾部存入有向计算图，后续释放有向计算图时，依次从队列头部释放有向计算图；

步骤3023、判断控制队列中是否存储有多个有向计算图，判断为是的情况下处理进行到步骤3024，判断为否的情况下，也即控制队列中只存储有一个有向计算图，处理进行到步骤3025。

步骤3024、在控制队列中存储有多个有向计算图的情况下，按照队列方向，建立第i-1个存储空间中的有向计算图中与串行模块对应的节点至第i个存储空间中有向计算图的相同节点的输出边；2≤i≤n，n为控制队列中存储空间的数量，n为自然数。

也即，主线程建立相邻的两个有向计算图中对应于串行模块的节点之间的连接边，例如，在控制队列中存入了第二个有向计算图后，建立第一个有向计算图中对应于一个串行计算模块的节点，与第二个有向计算图中对应于相同串行模块的节点之间的连接边，该连接边为输出边；如此，在控制队列中存入了第三个有向计算图后，建立第二个有向计算图中对应于一个串行计算模块的节点，与第三个有向计算图中对应于相同串行模块的节点之间的输出边。建立有向计算图之间对应于串行计算模块的节点连接边，而并行计算模块之间不具有这样的连接边，可以使得并行模块执行并行处理的同时串行模块执行串行处理，并且保证串行模块的执行顺序不会发生错乱。

步骤3025、主线程初始化控制队列中新存入的有向计算图中节点和连接边的状态。

其中，节点的状态包括：未就绪(unready)、就绪(ready)、运行(run) 和结束(done)；连接边的状态包括：未完成(uncomplete)和完成(complete)。

在一个实施例中，主线程判断新存入的有向计算图是否是控制队列中存储的第一个有向计算图；

在判断为是的情况下，将该有向计算图的起始节点设置为ready，将该有向计算图中的其它全部节点的状态设置为unready，将该有向计算图的全部连接边设置为uncomplete；

在判断为否的情况下，对于与该有向计算图相邻的上一个有向计算图的节点连接至该有向计算图的相同节点连接边，在相邻的上一个有向计算图的相同节点的状态为done的情况下，将该连接边的状态设置为complete，否则，将该连接边的状态设置为uncomplete；并且，将该有向计算图中节点的输入边均为complete的节点设置为ready，将其它全部节点的状态设置为unready，将该有向计算图的全部连接边设置为uncomplete。

例如，对于存储到控制队列中的第一个有向计算图，主线程会将该第一个有向计算图的起始节点设置为ready，将其它节点的状态设置为 unready，将该第一个有向计算图中的全部连接边设置为uncomplete；对后续存入的有向计算图，对于上一个有向计算图连接至该有向计算图的连接边(即输出边)，在上一个有向计算图中相应节点的状态为done的情况下，将该连接边设置为complete，否则，将该连接边设置为uncomplete，并且，在该有向计算图中的节点的输入边均为complete的情况下，将该节点的状态设置为ready，将其它节点的状态设置为unready，将该有向计算图中全部连接边的状态设置为uncomplete。

步骤303、根据有向计算图的计算方向以及节点的状态确定待调用节点，其中，待调用节点包括节点的多个输入边均为完成状态的节点。

在一个实施例中，在计算起始时，主线程在初始化控制队列中新存入的有向计算图中节点和连接边的状态后，主线程根据计算方向遍历控制队列中各有向计算图中的各个节点的状态，将状态为ready的节点确定为待调用的节点；将待调用节点的状态修改为run，并待调用节点推送到计算队列中；并且主线程进入等待状态。

或者，在一个实施例中，在计算过程中，线程池中的一个从线程根据计算方向遍历控制队列中各有向计算图中的各个节点的状态，将状态为 ready的节点确定为待调用节点，其中，状态为ready的节点包括节点的多个输入边均为complete状态的节点，将待调用节点的状态修改为run，并将待调用节点推送到计算队列中。

也即，只有节点的多个输入边的状态均为complete的节点才是待调用节点，这样能够保证调用节点对应的计算模块时，计算模块的多个输入数据都是同一个计算周期中的输入数据，从而能够保证多模块调用中计算模块的输入数据的一致性。

步骤304、向待调用节点对应的从进程中的计算模块发送远程过程调用 (RPC)的调用请求以执行该计算模块；

在一个实施例中，线程池中的一个从线程从计算队列中取出一个节点，向该节点对应的从进程中的计算模块发送RPC的调用请求。

更进一步，在另一个实施例中，根据预存的配置文件，线程池中的一个从线程确定从计算队列中取出的节点所对应的计算模块的标识、以及计算模块的输入数据的存储地址和/或输出数据的存储地址，将该计算模块的标识、输入数据的存储地址和/或输出数据的存储地址携带在调用请求中；在具体的应用场景中，根据不同的计算模块来区别调用请求中携带的信息，包括：将计算模块的标识、输入数据的存储地址和输出数据的存储地址携带在调用请求中，或者将计算模块的标识和输出数据的存储地址携带在调用请求中，或者将计算模块的标识和输入数据的存储地址携带在调用请求中；

其中，计算模块的输出数据的存储地址是计算模块所在的从进程所对应的共享存储空间中的地址，该地址与计算模块相对应；或者，输出数据的存储地址是另一个从进程所应对的共享存储空间中的地址，该地址与计算模块相对应，也即在另一个从进程中具有与该计算模块对应的存储地址；计算模块的输入数据的存储地址是计算模块所在的从进程所对应的共享存储空间中的地址。

也即，在每个从进程中都具有一个对应的共享存储空间。在一个从进程的共享存储空间中，从进程的每个计算模块在共享存储空间中具有一个对应的存储空间。计算模块将处理的结果也即输出数据写入到与模块对应的存储空间中。根据计算方向，一个计算模块的输出数据是另一个计算模块的输入数据，则另一个计算模块的输入数据的存储地址是该计算模块的输出数据的存储地址。

当一个计算模块需要同一个从进程中的另一个计算模块的输出数据作为输入数据时，主线程在调用请求中携带另一个计算模块的存储空间的地址作为该计算模块的输入数据的存储地址，该计算模块根据调用请求直接从另一个计算模块对应的存储空间中读取所需的输入数据。

在当前从进程中的一个计算模块B需要另一个从进程中的计算模块A 的输出数据作为输入数据时，主线程在发送给计算模块A的调用请求中携带计算模块A在当前从进程中的存储空间的地址作为该计算模块A的输出数据的存储地址，计算模块B从计算模块A在当前从进程的共享存储空间中的存储地址中获取数据作为输入数据，这一部分将在后续对从进程的工作原理的说明中进行阐述。

步骤305、在收到针对调用请求的应答响应后，更新该节点的状态和该节点的输出边的状态；

在一个实施例中，线程池中的一个从线程在收到针对一个节点所发出的调用请求的应答响应后，将该节点的状态设置为done，将该节点的输出边的状态修改为complete，并且将所有输入边均为complete的节点的状态设置为ready。

这样，节点对应的计算模块执行完处理后，从线程将该节点的状态设置为done，将节点的输出边的状态修改为complete，所有输入边的状态均为complete、节点状态为ready的节点即为一个待调用节点。根据上述步骤 303的处理，从线程将会将该节点确定为待调用节点，并将节点推送到计算队列中。

步骤306、在确定有向计算图的全部节点的状态更新结束后，并进行下一个计算周期的处理。

在一个实施例中，线程池中的一个从线程遍历处于控制队列头部的有向计算图中的各个节点的状态，在确定该子图中所有节点的状态为done的情况下，释放控制队列头部的有向计算图，向处于等待状态的主线程发送针对该子图的通知(Notify)，以使主线程进行下一个计算周期的处理。

也即，控制队列头部的有向计算图中所有节点的状态均为done时，该有向计算图对应的计算模块在当前计算周期的处理执行完成，从线程释放该有向计算图，并通知(Notify)或者唤醒处于等待状态的主线程进行相应的处理。

从上述处理过程中可以看出，本申请实施例提供的主进程端的多模块调度方法，能够由主进程来控制从进程中的多个计算模块的计算逻辑，并且在一个节点的多个输入边的状态均为完成的情况下，该节点对应的模块才能够得到调用进行计算或处理，能够保证计算模块的在一个计算周期中的输入数据的一致性，不会出现多个输入数据来自于不同的计算周期的情况，从而能够解决现有技术中计算模块的输入数据不一致的问题。

进一步，在主进程通过RPC向从进程中的计算模块发送调用请求时，在调用请求中携带计算模块的输入数据的存储地址和输出数据的存储地址，输入数据的存储地址和输出数据的存储地址为从进程对应的共享存储空间中的地址，这些计算模块之间的数据通信可以通过在共享存储空间中进行数据的读写来实现，能够提高模块之间的通信效率、降低通信时延、提高处理吞吐量，从而能够解决现有技术中计算模块之间的通信效率低、时延大、吞吐量低的问题。更进一步地，在计算模块的输出数据的地址是另一个从进程中的共享存储空间中的地址的情况下，还能跨进程将输出数据写入到其它从进程的共享存储空间中，从而能够实现计算模块之间跨进程的数据通信。

更进一步，主线程在控制队列中的多个存储空间中分别存入有向计算图，在有向计算图之间，建立相邻的前一个有向计算图中对应串行模块的节点至后一个有向计算图该相同节点的输出边，也即对串行模块进行调度时，需要根据前一个有向计算图中节点对应的串行模块的执行情况来调度串行模型的执行，而并行模块并不具有这样的约束，从而并行模块能够执行并行处理，提高处理速度。

本申请的实施例还提供了一种多模块调度方法，该方法应用在图2的从进程中，如图4所示，本申请提供的多模块调度方法的处理流程包括如下过程：

步骤401、在当前计算周期中，从进程的一个计算模块接收来自主进程的远程过程调用(RPC)的调用请求，其中，从进程中包括根据计算方向组合的多个计算模块；对于具有多个输入数据的计算模块，调用请求是主进程在确定计算模块的多个输入数据都已就绪的情况下发出的；

在一个实施例中，接收到的调用请求中包括计算模块的标识、输入数据的存储地址和/或输出数据的存储地址；输出数据的存储地址是从进程所对应的共享存储空间中的地址，该地址与计算模块相对应；或者，输出数据的存储地址是另一个从进程所应对的共享存储空间中的地址，该地址与计算模块相对应；输入数据的存储地址是从进程所对应的共享存储空间中的地址；在具体的应用场景中，根据计算模块的不同，调用请求中携带的信息不同，包括：将计算模块的标识、输入数据的存储地址和输出数据的存储地址携带在调用请求中，或者将计算模块的标识和输出数据的存储地址携带在调用请求中，或者将计算模块的标识和输入数据的存储地址携带在调用请求中；

在另一个实施例中，为了便于实现计算模块以及计算模块的远程调用，可以将计算模块封装成一个服务(Service)函数。

步骤402、该计算模块响应于调用请求执行处理。

与上述实施例相对应，计算模块响应于调用请求，从输入数据的存储地址读取输入数据执行处理，并将输出数据写入到输出数据的存储地址中。在输入数据的存储地址和输出数据的存储地址都是当前从进程中的共享存储空间的情况下，计算模块之间可以高效地进行数据的通信。

进一步，在计算模块的输出数据的存储地址是在另一个从进程的共享存储空间中所对应的地址的情况下，计算模块将处理结果作为输出数据写入到另一个从进程的共享存储空间中与该计算模块相对应的地址中，从而实现计算模块之间跨进程的数据传输。

步骤403、在处理执行完成后，计算模块向主进程反馈应答响应。

从上述处理过程中可以看出，根据本申请实施例提供的从进程端的多模块调度方法，从进程不对计算逻辑进行控制，计算模块响应于主进程的调用而执行处理，对于具有多个输入数据的计算模块，调用请求是主进程在确定计算模块的多个输入数据都已就绪的情况下发出的，这样能够保证计算模块在一个计算周期中的输入数据的一致性，不会出现多个输入数据来自于不同的计算周期的情况，从而能够解决现有技术中计算模块的输入数据不一致的问题。

进一步地，从进程中的计算模块响应于调用请求，分析得到调用请求中携带的计算模块的输入数据的存储地址和输出数据的存储地址，输入数据的存储地址和输出数据的存储地址均为从进程对应的共享存储空间中的地址，这些计算模块之间的数据通信可以通过在共享存储空间中进行数据的读写来实现，能够提高模块之间的通信效率、降低通信时延、提高处理吞吐量，从而能够解决现有技术中计算模块之间的通信效率低、时延大、吞吐量低的问题。更进一步地，在计算模块的输出数据的地址是另一个从进程中的共享存储空间中的地址的情况下，海能够跨进程实现计算模块之间的数据通信。

基于相同的发明构思，本申请的实施例还相应地提供了一种多模块调度装置，如图5a所示，该装置包括：

读取模块51，用于读取预存的配置文件，配置文件中保存有一个有向计算图；其中，有向计算图与一个计算任务相对应，计算任务包括多个从进程，每个从进程包括按照计算方向组合的多个计算模块，计算模块包括并行计算模块和串行计算模块；有向计算图中包括多个节点，每个节点对应一个从进程中的一个计算模块，节点之间具有连接边，进入节点的连接边为输入边，离开节点的连接边为输出边。

节点的状态包括：未就绪(unready)、就绪(ready)、运行(run)和结束(done)；连接边的状态包括：未完成(uncomplete)和完成(complete)。

执行模块53，用于在当前计算周期中，初始化节点和连接边的状态；根据有向计算图的计算方向以及节点的状态确定待调用节点，其中，待调用节点包括节点的多个输入边均为完成状态的节点；向待调用的节点对应的从进程中的计算模块发送远程过程调用(RPC)的调用请求以执行该计算模块；在收到针对调用请求的应答响应后，更新该节点的状态和该节点的输出边的状态；在确定有向计算图的全部节点的状态更新结束后，进行下一个计算周期的处理。

在一个实施例中，如图5b所示，执行模块53包括主线程模块531和线程池模块532，线程池模块532中包括多个从线程模块533。

执行模块53初始化节点和连接边的状态，包括：主线程模块531判断断控制队列中是否有空闲存储空间，在判断为否的情况下，主线程模块将自身的状态设置为等待(wait)，在判断为是的情况下，将一个有向计算图存入到一个控制队列的空闲存储空间中；在控制队列中存储有多个有向计算图的情况下，按照队列方向，建立第i-1个存储空间中的有向计算图中与串行模块对应的节点至第i个存储空间中有向计算图的相同节点的输出边； 2≤i≤n，n为控制队列中存储空间的数量，n为自然数；初始化控制队列中新存入的有向计算图中节点和连接边的状态。

主线程模块531初始化控制队列中新存入的有向计算图中节点和连接边的状态，包括：主线程模块531判断新存入的有向计算图是否是控制队列中存储的第一个有向计算图；在判断为是的情况下，将该有向计算图的起始节点设置为ready，将该有向计算图中的其它全部节点的状态设置为 unready，将该有向计算图的全部连接边设置为uncomplete；在判断为否的情况下，对于与该有向计算图相邻的上一个有向计算图的节点连接至该有向计算图的相同节点连接边，在相邻的上一个有向计算图的相同节点的状态为done的情况下，将该连接边的状态设置为complete，否则，将该连接边的状态设置为uncomplete；并且，将该有向计算图中节点的输入边均为 complete的节点设置为ready，将其它全部节点的状态设置为unready，将该有向计算图的全部连接边设置为uncomplete。

执行模块53根据有向计算图的计算方向以及节点的状态确定待调用节点，包括：主线程模块531在初始化控制队列中新存入的有向计算图中节点和连接边的状态后，根据计算方向遍历控制队列中各有向计算图中的各个节点的状态，将状态为ready的节点确定为待调用节点，其中，状态为ready 的节点包括节点的多个输入边均为complete状态的节点；将待调用节点的状态修改为run，并待调用节点推送到计算队列中，并且主线程模块进入等待状态；或者，

计算过程中，线程池模块532中的一个从线程模块533根据计算方向遍历控制队列中各有向计算图中的各个节点的状态，将状态为ready的节点确定为待调用节点，其中，状态为ready的节点包括节点的多个输入边均为 complete状态的节点，将待调用节点的状态修改为run，并待调用节点推送到计算队列中。

执行模块53向待调用的节点对应的从进程中的计算模块发送RPC的调用请求以执行该计算模块，包括：线程池模块532中的一个从线程模块533 从计算队列中取出一个节点，向该节点对应的从进程中的计算模块发送 RPC的调用请求。

从线程模块533还用于：根据预存的配置文件，确定从计算队列中取出的节点所对应的计算模块的标识、以及计算模块的输入数据的存储地址和/或输出数据的存储地址，将该计算模块的标识、输入数据的存储地址和/ 或输出数据的存储地址携带在调用请求中。计算模块的输出数据的存储地址是计算模块所在的从进程所对应的共享存储空间中的地址，该地址与计算模块相对应，或者，输出数据的存储地址是另一个从进程所应对的共享存储空间中的地址，该地址与计算模块相对应。计算模块的输入数据的存储地址是计算模块所在的从进程所对应的共享存储空间中的地址。

执行模块53在收到针对调用请求的应答响应后，更新该节点的状态和该节点的输出边的状态，包括：线程池模块532中的一个从线程模块533 在收到针对一个节点所发出的调用请求的应答响应后，将该节点的状态设置为done，将该节点的输出边的状态修改为complete，并且将所有输入边均为complete的节点的状态设置为ready。

执行模块53在确定有向计算图的全部节点的状态更新结束时，进行下一个计算周期的处理，包括：线程池模块532中的一个从线程模块533遍历控制队列头部的有向计算图中的各个节点的状态，在确定该有向计算图中所有节点的状态为done的情况下，释放控制队列头部的有向计算图，向处于等待状态的主线程模块531发送通知(Notify)，以使主线程进行下一个计算周期的处理。

根据图5a或者图5b所示的多模块调度装置，能够由作为主进程的多模块调度装置来控制从进程中的多个计算模块的计算逻辑，并且在一个计算周期中，在一个节点的多个输入边的状态均为完成的情况下，该节点对应的模块才能够得到调用进行计算或处理，能够保证计算模块的在一个计算周期中的输入数据的一致性，不会出现多个输入数据来自于不同的计算周期的情况，从而能够解决现有技术中计算模块的输入数据不一致的问题。

进一步，在主进程模块通过RPC向从进程中的计算模块发送调用请求时，在调用请求中携带计算模块的输入数据的存储地址和输出数据的存储地址，输入数据的存储地址和输出数据的存储地址为从进程对应的共享存储空间中的地址，这些计算模块之间的数据通信可以通过在共享存储空间中进行数据的读写来实现，能够提高模块之间的通信效率、降低通信时延、提高处理吞吐量，从而能够解决现有技术中计算模块之间的通信效率低、时延大、吞吐量低的问题。更进一步地，在计算模块的输出数据的地址是另一个从进程中的共享存储空间中的地址的情况下，还能够实现计算模块之间跨进程的数据通信。

更进一步，主线程在控制队列中的多个存储空间中分别存入有向计算图，在有向计算图之间，建立相邻的前一个有向计算图中对应串行模块的节点至后一个有向计算图该相同节点的输出边，也即对串行模块进行调度时，需要根据前一个有向计算图中节点对应的串行模块的执行情况来调度串行模型的执行，而并行模块并不具有这样的约束，从而并行模块能够执行并行处理，提高处理速度。

基于相同的发明构思，本申请实施例还提供了一种多模块调度装置，该多模块调度装置应用在一个从进程中，从进程中包括按照计算方向组合的多个多模块调度装置，如图6所示，该装置包括：

接收模块61，用于在当前计算周期中，接收来自主进程的远程过程调用(RPC)的调用请求；对于具有多个输入数据的多模块调度装置，调用请求是主进程在确定多模块调度装置的多个输入数据都已就绪的情况下发出的；

在一个实施例中，接收模块接收到的调用请求中包括计算模块的标识、输入数据的存储地址和/或输出数据的存储地址；输出数据的存储地址是从进程所对应的共享存储空间中的地址，该地址与计算模块相对应；或者，输出数据的存储地址是另一个从进程所应对的共享存储空间中的地址，该地址与计算模块相对应。输入数据的存储地址是从进程所对应的共享存储空间中的地址。

执行模块63，用于响应于调用请求执行处理；

在一个实施例中，从输入数据的存储地址读取输入数据执行处理，并将输出数据写入到输出数据的存储地址中。

在一个实施例中，在输出数据的存储地址是另一个从进程所对应的共享存储空间中的地址的情况下，执行模块将处理结果作为输出数据写入到多模块调度装置在另一个从进程的共享存储空间中对应的存储地址中。

反馈模块65，用于在执行模块执行完处理后，计算模块向主进程反馈应答响应。

根据本申请实施例提供的从进程端的多模块调度装置，从进程端不对计算逻辑进行控制，作为计算模块的多模块调度装置响应于主进程的调用而执行处理，对于具有多个输入数据的计算模块，调用请求是主进程在确定计算模块的多个输入数据都已就绪的情况下发出的，这样能够保证计算模块在一个计算周期中的输入数据的一致性，不会出现多个输入数据来自于不同的计算周期的情况，从而能够解决现有技术中计算模块的输入数据不一致的问题。

进一步地，从进程中的计算模块(多模块调度装置)响应于调用请求，分析得到调用请求中携带的输入数据的存储地址和输出数据的存储地址，输入数据的存储地址和输出数据的存储地址为从进程对应的共享存储空间中的地址，这些计算模块(多模块调度装置)之间的数据通信可以通过在共享存储空间中进行数据的读写来实现，能够提高模块(多模块调度装置) 之间的通信效率、降低通信时延、提高处理吞吐量，从而能够解决现有技术中计算模块之间的通信效率低、时延大、吞吐量低的问题。更进一步地，在计算模块的输出数据的地址是另一个从进程中的共享存储空间中的地址的情况下，还能够跨进程实现计算模块之间的数据通信。

基于相同的发明构思，本申请实施例还提供了一种多模块调度装置，如图7所示，该装置包括：一个处理器71和至少一个存储器73，至少一个存储器73中存储有至少一条机器可执行指令，处理器71执行至少一条机器可执行指令以实现：

读取预存的配置文件，配置文件中保存有一个有向计算图；其中，有向计算图与一个计算任务相对应，计算任务包括多个从进程，每个从进程包括按照计算方向组合的多个计算模块；有向计算图中包括多个节点，每个节点对应一个从进程中的一个计算模块，节点之间具有连接边，进入节点的连接边为输入边，离开节点的连接边为输出边；

在当前计算周期中，主进程初始化点和连接边的状态；

根据有向计算图的计算方向以及节点的状态确定待调用节点，其中，待调用节点包括节点的多个输入边均为完成状态的节点；

向待调用节点对应的从进程中的计算模块发送远程过程调用(RPC)的调用请求以执行该计算模块；

在收到针对调用请求的应答响应后，更新该节点的状态和该节点的输出边的状态；

在确定有向计算图的全部节点的状态更新结束后，进行下一个计算周期的处理。

在一个实施例中，处理器71执行至少一条机器可执行指令以实现主线程和线程池，线程池中包括多个从线程；

节点的状态包括：未就绪(unready)、就绪(ready)、运行(run)和结束(done)；连接边的状态包括：未完成(uncomplete)和完成(complete)。

在一个实施例中，处理器71执行至少一条机器可执行指令以实现主进程初始化节点和连接边的状态，包括：主线程根据预定时间间隔判断控制队列中是否有空闲存储空间，在判断为否的情况下，主线程将自身的状态设置为等待(wait)，在判断为是的情况下，将一个有向计算图存入到一个控制队列的空闲存储空间中；在控制队列中存储有多个有向计算图的情况下，按照队列方向，建立第i-1个存储空间中的有向计算图中与串行模块对应的节点至第i个存储空间中有向计算图的相同节点的输出边；2≤i≤n，n 为控制队列中存储空间的数量，n为自然数；初始化控制队列中新存入的有向计算图中节点和连接边的状态。

在一个实施例中，处理器71执行至少一条机器可执行指令以实现初始化控制队列中新存入的有向计算图中节点和连接边的状态，包括：主线程判断新存入的有向计算图是否是控制队列中存储的第一个有向计算图；在判断为是的情况下，将该有向计算图的起始节点设置为ready，将该有向计算图中的其它全部节点的状态设置为unready，将该有向计算图的全部连接边设置为uncomplete；在判断为否的情况下，对于与该有向计算图相邻的上一个有向计算图的节点连接至该有向计算图的相同节点连接边，在相邻的上一个有向计算图的相同节点的状态为done的情况下，将该连接边的状态设置为complete，否则，将该连接边的状态设置为uncomplete；并且，将该有向计算图中节点的输入边均为complete的节点设置为ready，将其它全部节点的状态设置为unready，将该有向计算图的全部连接边设置为 uncomplete。

在一个实施例中，处理器71执行至少一条机器可执行指令以实现根据有向计算图的计算方向以及节点的状态确定待调用节点，包括：主线程在初始化控制队列中新存入的有向计算图中节点和连接边的状态后，根据计算方向遍历控制队列中个有向计算图中的各个节点的状态，将状态为ready 的节点确定为待调用节点，其中，状态为ready的节点包括节点的多个输入边均为complete状态的节点；将待调用节点的状态修改为run，并将待调用节点推送到计算队列中，并且主线程进入等待状态；或者，在计算过程中，线程池中的一个从线程根据计算方向遍历控制队列中各有向计算图中的各个节点的状态，将状态为ready的节点确定为待调用的节点，其中，状态为 ready的节点包括节点的多个输入边均为complete状态的节点；将待调用节点的状态修改为run，并将待调用节点推送到计算队列中。

在一个实施例中，处理器71执行至少一条机器可执行指令以实现向待调用的节点对应的从进程中的计算模块发送RPC的调用请求以执行该计算模块，包括：线程池中的一个从线程从计算队列中取出一个节点，向该节点对应的从进程中的计算模块发送RPC的调用请求。

在一个实施例中，处理器71执行至少一条机器可执行指令还实现：根据预存的配置文件，线程池中的一个从线程确定从计算队列中取出的节点所对应的计算模块的标识、以及计算模块的输入数据的存储地址和/或输出数据的存储地址，将该计算模块的标识、输入数据的存储地址和/或输出数据的存储地址携带在调用请求中。计算模块的输出数据的存储地址是计算模块所在的从进程所对应的共享存储空间中的地址，该地址与计算模块相对应；或者，输出数据的存储地址是另一个从进程所应对的共享存储空间中的地址，该地址与计算模块相对应。计算模块的输入数据的存储地址是计算模块所在的从进程所对应的共享存储空间中的地址。

在一个实施例中，处理器71执行至少一条机器可执行指令以实现：在收到针对调用请求的应答响应后，更新该节点的状态和该节点的输出边的状态，包括：线程池中的一个从线程在收到针对一个节点所发出的调用请求的应答响应后，将该节点的状态设置为done，将该节点的输出边的状态修改为complete，并且将所有输入边均为complete的节点的状态设置为 ready。

在一个实施例中，处理器71执行至少一条机器可执行指令以实现：在确定有向计算图的全部节点的状态更新结束时，进行下一个计算周期的处理，包括：线程池中的一个从线程遍历控制队列头部的有向计算图中的各个节点的状态，在确定该有向计算图中所有节点的状态为done的情况下，释放控制队列头部的存储空间，并向处于等待状态的主线程发送针对该子图的通知(Notify)，以使主线程进行下一个计算周期的处理。

根据相同的发明构思，本申请实施例还提供了一种多模块调度装置，如图8所示，该装置包括：一个处理器81和至少一个存储器83，至少一个存储器83中存储有至少一条机器可执行指令，处理器81执行至少一条机器可执行指令以实现：

在当前计算周期中，收来自主进程的远程过程调用(RPC)的调用请求；对于具有多个输入数据的多模块调度装置，调用请求是主进程在确定多模块调度装置的多个输入数据都已就绪的情况下发出的；

响应于调用请求执行处理；

在处理执行完成后向主进程反馈应答响应。

在一个实施例中，处理器81执行至少一条机器可执行指令还实现：接收到的调用请求中包括计算模块的标识、输入数据的存储地址和/或输出数据的存储地址；输出数据的存储地址是从进程所对应的共享存储空间中的地址，该地址与计算模块相对应；或者，输出数据的存储地址是另一个从进程所应对的共享存储空间中的地址，该地址与计算模块相对应。输入数据的存储地址是从进程所对应的共享存储空间中的地址。

在一个实施例中，处理器81执行至少一条机器可执行指令以实现：响应于调用请求执行处理，包括：响应于调用请求，从输入数据的存储地址读取输入数据执行处理，并将输出数据写入到输出数据的存储地址中。

下面对本申请提供的技术方案在具体应用场景中的实现进行说明。

本申请提供的多模块调度方法可以应用在自动驾驶领域的深度学习中。

如图1所示，在现有技术中，自动驾驶领域的深度学习任务通常包括如下计算模块：摄像头(Sensor)、车辆检测(Detection)、车辆追踪(Tracking)、分割(Segmentation)、融合(Fusion)。摄像头模块获取无人驾驶车辆的驾驶环境的图像，车辆检测模块用于识别出摄像头拍摄的每帧图片中的车辆位置，车辆追踪模块用于将车辆检测模块的一段连续图像帧的输出作为输入，并标识出这段连续的图像帧内的相同的车辆，分割模块用于识别出车道线的位置，融合模块根据多个车载追踪模块的输出来计算车辆周围的路况信息。

将本申请提供的多模块调度方案应用在自动驾驶领域的深度学习任务中，如图9a所示，设置一个主进程(Master)，三个从进程(Server)，从进程1中包括计算模块：摄像头1、车辆检测1、车辆追踪1、融合1，从进程2中包括计算模块：摄像头2、车辆检测2、车辆追踪2，从进程3中包括计算模块：摄像头3、车辆检测3、车辆追踪、分割5。从进程1和从进程2设置在单机1上，主进程和从进程3设置在单机2上。图9a中计算模块之间的单向箭头表示计算方向和数据的传输方向，如在从进程1中车辆检测1的输入数据为摄像头1的输出数据，车辆追踪1的输入数据包括摄像头1的输出数据和车辆检测1的输出数据，计算模块融合1的输入数据包括从进程1中的车辆追踪1的输出数据、从进程2中的车辆追踪2的输出数据、从进程3中的车辆追踪3的输出数据和从进程3中的分割模块5 的输出数据。其它从进程中的计算方向与此同理，不做一一阐述。

每个从进程中分配有一个共享存储空间，并且在每个从进程的共享存储空间中都为从进程的每个计算模块分配有对应的存储地址，如图9a所示，为从进程1-3分配的共享存储空间为R1-R3，在从进程1的共享存储空间中分别为摄像头1、车辆检测1、车辆追踪1和融合1分配了各自对应的存储空间R1-S、R1-D、R1-T、R1-F，其它的从进程中也是类似的情况，从进程 2中的共享存储空间中包括R2-S、R2-D、R2-T，从进程3中的共享存储空间中包括R3-S、R3-D、R3-T、R3-G。计算模块之间通过将输出数据写入对应的存储空间，以及从共享存储空间中读取输入数据，来实现计算模块之间的数据传输。

仔细分析图9a可知，融合模块1需要跨进程读取输入数据。融合模块 1不仅需要同一个从进程中的车辆追踪模块1的输出数据，还需要从进程2 中的车辆追踪模块2的输出数据、从进程3中的车辆追踪模块3的输出数据、从进程3中的分割模块5的输出数据。从进程内部通过在共享存储空间中读写数据进行数据通信，不同从进程的计算模块之间无法通过这样的方法进行数据通信。

为了解决这一问题，在深度学习任务中，为需要进行跨进程进行数据传输的模块设置拷贝模块，并且为拷贝模块分配跨进程的共享存储空间中的存储地址作为输出数据的存储地址，主进程在发送给拷贝模块的RPC调用请求中携带该输出数据的存储地址。如图9b所示，从进程1的共享存储空间中还为从进程2中的拷贝模块4’、从进程3中的拷贝模块4”、从进程 3中的拷贝模块4”’分别分配了各自对应的存储空间，具体为：R1-2C、 R1-3C、R1-4C。

如图9b所示，拷贝模块2用于根据主进程的RPC请求，在从进程2 的共享存储空间中车辆追踪2对应的存储空间R2-T中读出数据，并将读出的数据作为输出数据写入到拷贝模块2在从进程1的共享存储空间中对应的存储地址R1-2C中，拷贝模块3和拷贝模块4的工作原理与此类似。

通过设置拷贝模块，能够实现计算模块之间跨进程的数据传输。

此外，在图9a中，计算模块车辆检测1、车辆检测2、车辆检测3是三个同一计算时序的相同的并行计算模块，其它模块均为串行计算模块。图9b中的拷贝模块并不是执行学习任务的模块，不属于并行计算模块或者串行计算模块。

与图9b相对应，预先为深度学习任务生成一个配置文件，配置文件中保存有一个有向计算图，如图9c所示，其中，对应于从进程1，节点1代表摄像头1，节点2代表车辆检测1、节点3代表车辆追踪1、节点4代表融合模块；对应于从进程2，节点1’代表摄像头2，节点2代表车辆检测2，节点3’代表车辆追踪2；对应于从进程3，节点1”代表摄像头3，节点2”代表车辆检测3，节点3”代表车辆追踪3，节点5代表从进程3中的分割模块5。此外，节点4’代表从进程2中的拷贝模块2，节点4”代表从进程3 中的拷贝模块3，节点4”’代表从进程3中的拷贝模块4。

在图10中示出了主进程根据预定的时间间隔(例如20毫秒)依次读入到控制队列的三个空闲存储空间中的有向计算图，为了区分不同存储空间中的有向计算图，将存储空间2中的节点均后缀A，例如节点1A对应图 9C中的节点1，节点1A’对应于图9c中的节点1’，将存储空间3中的节点均后缀B，例如节点1B对应图9C中的节点1，节点1B’对应于图9C中的节点1’。主线程依次将有向计算图存储到控制队列中后，还会在处理过程中建立相邻两个有向计算图之间对应于串行模块的节点的输出边，例如建立节点1至1A的输出边，建立节点1A至1B的输出边，其它节点类似，不一一赘述。为了方便参考和说明，图10中示出了有向计算图之间连接边建立完成的图示。图10中模块之间的单向箭头表示计算方向和数据的传输方向，图10中的计算方向和数据传输方向和图9中的计算方向和传输方向一致。

参考图11a～c中列出的处理过程表，下面通过一个整体的处理流程来说明图9b所示计算模块的处理过程。在图11a～c中，“从线程”代表执行处理的从进程，“调用节点”为从线程从计算队列中取出的节点，“输入数据”

表示调用节点对应的计算模块执行处理时的输入数据，“输出数据”表示调用节点对应的计算模块执行处理时的输出数据，“执行完成后更新的连接边”表示计算模块执行处理完成后，从线程所更新的相应的节点的输出边，“ready节点”为从线程或者主线程根据更新后的连接边确定得到的处于ready状态的节点。

步骤S1、主进程中的主线程读取配置文件，获取如图9c所示的有向计算图；

步骤S2、主线程判断控制队列中是否还有空闲存储空间，在判断为否的情况下(也即控制队列中没有空闲存储空间)处理进行到步骤S3，在判断为否的情况下(也即控制队列中还有空闲存储空间)处理进行到步骤S5；

步骤S3、主线程进入等待(wait)状态；

步骤S4、处于等待状态的主线程接收到来自一个从线程的通知 (Notify)，处理返回步骤S2；

步骤S5、主线程根据预定的时间间隔(例如20毫秒)分别将一个有向计算图作为子图存储到控制队列的队尾；

具体地，将子图1存储到控制队列中的存储空间1中；

步骤S6、主线程判断控制队列中是否存储有多个子图，在判断为是的情况下，处理进行到步骤S7，在判断为否的情况下，处理进行到步骤S9；

步骤S7、主线程建立当前新存入的子图的前一个子图中串行计算模块对应的节点，与当前新存入的子图中相同节点之间的连接边，该连接边为输出边；

步骤S8、在前一个子图中对应节点的状态为done的情况下，将该连接边设置为complete，否则，将该连接边设置为uncomplete；

步骤S9、主线程将新存入的子图中输入边的状态均为complete的节点的状态设置为ready，其它节点的状态设置为unready，并将所有的连接边的状态设置为uncomplete；

具体地，主线程将子图1中的起始节点节点1、节点1’、节点1”的状态设置为ready，3个子图中其它全部节点的状态设置为unready，将逆向连接边3B-3、3B’-3’、3B”-3”的状态设置为complete，将其它所有连接边的状态设置为uncomplete；

步骤S10、主线程将状态为ready的节点的状态修改为run，并将状态为run的节点推送到计算队列中；处理返回步骤S2；

具体地，主线程将子图1中的节点1、节点1’、节点1”的状态修改为 run，并将节点1、节点1’、节点1”推送到计算队列中；返回到步骤S2；

主进程返回到步骤S2后，执行步骤S2、S5-S10，在控制队列的队尾存储空间2中写入子图2，在子图1的节点1、1’、1”对应的计算模块未执行完成、状态不为done的情况下，处理返回步骤S2，在子图1的节点1、1’、 1”对应的计算模块执行完成、状态为done的情况下，将子图2的节点1A、 1A’、1A”的推送到计算队列中，否则返回步骤S2；(注，在以下的说明中，以节点1、1’、1”对应的计算模块未执行完成、状态不为done的情况的进行说明)；

主进程继续执行步骤S2、S5-S10，在控制队列的队尾存储空间3中写入子图3，在子图2的节点1A、1A’、1A”对应的计算模块未执行完成、状态不为done的情况下，处理返回步骤S2，在子图2的节点1A、1A’、1A”执行完成、状态为done的情况下，将子图3的节点1B、1B’、1B”推送到计算队列中，返回步骤S2，并进行到步骤S3；(注，在以下的说明中，以节点1A、1A’、1A”对应的计算模块未执行完成、状态不为done的情况的进行说明)；

注：在以下的说明中，线程池中的从线程与从进程或者计算模块之间均不存在对应关系，以下为了方便说明按照从线程的顺序进行说明；

步骤S11、线程池中的一个从线程a从计算队列中取出节点1，向节点1对应的计算模块摄像头1发送RPC调用请求，在请求中携带输出数据的存储地址，也即摄像头1在从进程1的共享存储空间中的存储地址R1-S；

线程池中的一个从线程b从计算队列中取出节点1’，向节点1’对应的模块摄像头2发送RPC调用请求，在请求中携带输出数据的存储地址，也即摄像头2在从进程2的共享存储空间中的存储地址R2-S；

线程池中的一个从线程c从计算队列中取出节点1”，向节点1”对应的模块摄像头3发送RPC调用请求，在请求中携带输出数据的存储地址，也即摄像头3在从进程3的共享存储空间中的存储地址R3-S；

步骤S12、响应于调用请求，摄像头1将获取的第一帧图像数据T1写入到进程1中的存储地址R1-S内，向从线程a反馈应答响应；

响应于调用请求，摄像头2将获取的第一帧图像数据T1写入到进程2 中的存储地址R2-S内，向从线程b反馈应答响应；

响应于调用请求，摄像头3将获取的第一帧图像数据T1写入到进程3 中的存储地址R3-S内，向从线程c反馈应答响应；

步骤S13、从线程a接收到应答响应后，将节点1的状态设置为done，并将节点1的两个输出边1-2、1-3、1-1A的状态设置为complete；

从线程b接收到应答响应后，将节点1’的状态设置为done，并将节点 1’的三个输出边1’-2’、1’-3’、1’-1A’的状态设置为complete；

从线程c接收到应答响应后，将节点1”的状态设置为done，并将节点 1’的四个输出边1”-2”、1”-3”、1”-5、1”-1A”的状态设置为complete；

步骤S14、从线程a将输入边的状态为complete的节点2和1A的状态修改为ready；

从线程b将输入边的状态为complete的节点2’和1A’的状态修改为 ready；

从线程c将输入边的状态为complete的节点2”、5和1A”的状态修改为ready；

步骤S15、从线程a遍历有向计算图中各个节点的状态，将状态为ready 的节点2、1A的状态设置为run，将节点2、1A推送到计算队列中；

从线程b遍历有向计算图中各个节点的状态，将状态为ready的节点2’、 1A’的状态设置为run，将节点2’、1A’推送到计算队列中；

从线程c遍历有向计算图中各个节点的状态，将状态为ready的节点2”、 5和1A”的状态设置为run，将节点2”、5、1A”推送到计算队列中；

步骤S16、从线程a从计算队列中取出从计算队列中取出节点2，向节点2对应的模块车辆检测1发送RPC调用请求，在请求中携带输入数据的存储地址和输出数据的存储地址，输入数据地址为摄像头1在从进程1的共享存储空间中的存储地址R1-S，输出数据地址为车辆检测1在从进程1 的共享存储空间中的存储地址R1-D；

从线程b从计算队列中取出从计算队列中取出节点1A，向节点1A对应的模块摄像头1发送RPC调用请求，在请求中携带输出数据的存储地址，输出数据地址为摄像头1在进程1的共享存储空间中的存储地址R1-S；

从线程c从计算队列中取出节点2’，向节点2’对应的模块车辆检测2 发送RPC调用请求，在请求中携带输入数据的存储地址和输出数据的存储地址，输入数据地址为摄像头2在从进程2的共享存储空间中的存储地址 R2-S，输出数据地址为车辆检测2在从进程2的共享存储空间中的存储地址R2-D；

从线程d从计算队列中取出从计算队列中取出节点1A’，向节点1A’对应的模块摄像头2发送RPC调用请求，在请求中携带输出数据的存储地址，输出数据地址为摄像头2在从进程2的共享存储空间中的存储地址R2-S；

从线程e从计算队列中取出节点2”，向节点2”对应的模块车辆检测3 发送RPC调用请求，在请求中携带输入数据的存储地址和输出数据的存储地址，输入数据地址为摄像头3在进程3的共享存储空间中的存储地址 R3-S，输出数据地址为车辆检测3在进程3的共享存储空间中的存储地址 R3-D；

从线程f从计算队列中取出节点5，向节点5对应的分割模块发送RPC 调用请求，在请求中携带输入数据的存储地址和输出数据的存储地址，输入数据地址为摄像头3在进程3的共享存储空间中的存储地址R3-S，输出数据地址为分割模块在进程3的共享存储空间中的存储地址R3-G；

从线程g从计算队列中取出从计算队列中取出节点1A”，向节点1A”对应的模块摄像头3发送RPC调用请求，在请求中携带输出数据的存储地址，输出数据地址为摄像头3在从进程3中的共享存储空间中的存储地址 R3-S；

步骤S17、根据调用请求，车辆检测1在从进程1的共享存储空间中读取输入数据T1，并执行处理，将输出数据T11写入到调用请求中指定的输出数据存储地址中，向从线程a反馈应答响应；

根据调用请求，摄像头1将获取的第二帧图像数据T2写入到调用请求中指定的输出数据存储地址中，向从线程b反馈应答响应；

根据调用请求，车辆检测2在从进程2的共享存储空间中读取输入数据T1，并执行处理，将输出数据T12写入到调用请求中指定的输出数据存储地址中，向从线程c反馈应答响应；

根据调用请求，摄像头2将获取的第二帧图像数据T2写入到调用请求中指定的输出数据存储地址中，向从线程d反馈应答响应；

根据调用请求，车辆检测3在从进程3的共享存储空间中读取输入数据T1，并执行处理，将输出数据T13写入到调用请求中指定的输出数据存储地址中，向从线程e反馈应答响应；

根据调用请求，分割模块5在从进程3的共享存储空间中读取输入数据T1，并执行处理，将输出数据T15写入到调用请求中指定的输出数据存储地址中，向从线程f反馈应答响应；

根据调用请求，摄像头3将获取的第二帧图像数据T2写入到调用请求中指定的输出数据存储地址中，向从线程g反馈应答响应；

步骤S18、从线程a接收到应答响应后，将节点2的状态设置为done，并将节点2的一个输出边2-3的状态设置为complete；

从线程b接收到应答响应后，将节点1A的状态设置为done，将节点 1A的三个输出边1A-2A、1A-3A、1A-1B的状态设置为complete；

从线程c接收到应答响应后，将节点2’的状态设置为done，并将节点 2’的一个输出边2’-3’的状态设置为complete；

从线程d接收到应答响应后，将节点1A’的状态设置为done，将节点 1A’的三个输出边1A’-2A’、1A’-3A’、1A’-1B’的状态设置为complete；

从线程e接收到应答响应后，将节点2”的状态设置为done，并将节点 2”的一个输出边2”-3”的状态设置为complete；

从线程f接收到应答响应后，将节点5的状态设置为done，并将节点5 的一个输出边5-4”’、5-5A的状态修改为complete；

从线程g接收到应答响应后，将节点1A”的状态设置为done，将节点 1A”的四个输出边1A”-2A”、1A”-3A”、1A”-1B”、1A”-5A的状态设置为complete；

步骤S19、从线程a将输入边1-3、2-3的状态均为complete的节点3 的状态修改为ready；

从线程b将输入边1A-2A的状态为complete的节点2A、输入边1A-1B 为complete的节点1B的状态修改为ready；

从线程c将输入边1’-3’、2’-3’的状态均为complete的节点3’的状态修改为ready；

从线程d将将输入边1A’-2A’的状态为complete的节点2A’、输入边 1A’-1B’为complete的节点1B’的状态修改为ready；

从线程e将输入边1”-3”、2”-3”的状态均为complete的节点3”的状态修改为ready；

从线程f将输入边5-4”’的状态为complete的节点4”’的状态修改为 ready；

从线程g将输入边1A”-2A”的状态为complete的节点2A”、输入边 1A”-5A、5-5A的状态为complete的节点5A、输入边1A”-1B”的状态为 complete的节点1B”的状态修改为ready；

步骤S20、从线程a遍历有向计算图中各个节点的状态，将状态为ready 的节点3的状态设置为run，将节点3推送到计算队列中；

从线程b遍历有向计算图中各个节点的状态，将状态为ready的节点 2A的状态设置为run，将节点2A推送到计算队列中；

从线程c遍历有向计算图中各个节点的状态，将状态为ready的节点 1B的状态设置为run，将节点1B推送到计算队列中；

从线程d遍历有向计算图中各个节点的状态，将状态为ready的节点3’的状态设置为run，将节点3’推送到计算队列中；

从线程e遍历有向计算图中各个节点的状态，将状态为ready的节点 2A’的状态设置为run，将节点2A’推送到计算队列中；

从线程f遍历有向计算图中各个节点的状态，将状态为ready的节点1B’的状态设置为run，将节点1B’推送到计算队列中；

从线程g遍历有向计算图中各个节点的状态，将状态为ready的节点3”的状态设置为run，将节点3”推送到计算队列中；

从线程h遍历有向计算图中各个节点的状态，将状态为ready的节点4”’的状态设置为run，将节点4”’推送到计算队列中；

从线程i遍历有向计算图中各个节点的状态，将状态为ready的节点2A”的状态设置为run，将节点2A”推送到计算队列中；

从线程j遍历有向计算图中各个节点的状态，将状态为ready的节点5A 的状态设置为run，将节点5A推送到计算队列中；

从线程k遍历有向计算图中各个节点的状态，将状态为ready的节点 1B”的状态设置为run，将节点1B”推送到计算队列中；

步骤S21、从线程a从计算队列中取出从计算队列中取出节点3，向节点3对应的模块车辆追踪1发送RPC调用请求，在请求中携带输入数据的存储地址和输出数据的存储地址，输入数据地址为摄像头1在从进程1的共享存储空间中的存储地址R1-S和车辆检测1在从进程1的共享存储空间中的地址R1-D，输出数据地址为车辆追踪1在从进程1的共享存储空间中的存储地址R1-T；

从线程b从计算队列中取出节点2A，向节点2A对应的模块车辆检测 1发送RPC调用请求，在请求中携带输入数据的存储地址和输出数据的存储地址，输入数据地址为摄像头1在从进程1的共享存储空间中的存储地址R1-S，输出数据地址为车辆检测1在从进程1的共享存储空间中的存储地址R1-D；

从线程c从计算队列中取出节点1B，向节点1B对应的模块摄像头1 发送RPC调用请求，在请求中携带输出数据的存储地址，输出数据地址为摄像头1在从进程1的共享存储空间中的存储地址R1-S；

从线程d从计算队列中取出节点3’，向节点3’对应的模块车辆追踪2 发送RPC调用请求，在请求中携带输入数据的存储地址和输出数据的存储地址，输入数据地址为摄像头2在进程2的共享存储空间中的存储地址R2-S 和车辆检测2在从进程2的共享存储空间中的地址R2-D，输出数据地址为车辆追踪2在从进程2的共享存储空间中的存储地址R2-T；

从线程e从计算队列中取出节点2A’，向节点2A’对应的模块车辆检测 2发送RPC调用请求，在请求中携带输入数据的存储地址和输出数据的存储地址，输入数据地址为摄像头2在从进程2的共享存储空间中的存储地址R2-S，输出数据地址为车辆检测2在从进程2的共享存储空间中的存储地址R2-D；

从线程f从计算队列中取出节点1B’，向节点1B’对应的模块摄像头2 发送RPC调用请求，在请求中输出数据的存储地址，输出数据地址为摄像头2在从进程2的共享存储空间中的存储地址R2-S；

从线程g从计算队列中取出节点3”，向节点3”对应的模块车辆追踪3 发送RPC调用请求，在请求中携带输入数据的存储地址和输出数据的存储地址，输入数据地址为摄像头3在从进程3的共享存储空间中的存储地址 R3-S和车辆检测3在从进程3的共享存储空间中的存储地址R3-D，输出数据地址为车辆追踪3在从进程3的共享存储空间中的存储地址R3-T；

从线程h从计算队列中取出节点4”’，向节点4”’对应的拷贝模块4发送RPC调用请求，在请求中携带输入数据的存储地址和输出数据的存储地址，输入数据地址为分割模块5在从进程3的共享存储空间中的存储地址 R3-G，输出数据地址为拷贝模块4在从进程1的共享存储空间中的存储地址R1-4C；

从线程i从计算队列中取出节点2A”，向节点2A”对应的车辆检测3发送RPC调用请求，在请求中携带输入数据的存储地址和输出数据的存储地址，输入数据地址为摄像头3在从进程3的共享存储空间中的存储地址 R3-S，输出数据地址为车辆检测3在从进程3的共享存储空间中的存储地址R3-D；

从线程j从计算队列中取出节点5A，向节点5A对应的分割5发送RPC 调用请求，在请求中携带输入数据的存储地址和输出数据的存储地址，输入数据地址为摄像头3在进程3的共享存储空间中的存储地址R3-S，输出数据地址为分割5在从进程3的共享存储空间中的存储地址R3-G；

从线程k从计算队列中取出节点1B”，向节点1B”对应的摄像头3发送RPC调用请求，在请求中携带输出数据的存储地址，输出数据地址为摄像头3在从进程3的共享存储空间中的存储地址R3-S；

步骤S22、根据调用请求，车辆追踪1在从进程1的共享存储空间中读取输入数据T1、T11，并执行处理，将输出数据T11’写入到调用请求中指定的输出数据存储地址中，向从线程a反馈应答响应；

根据调用请求，车辆检测1在从进程1的共享存储空间中读取输入数据T2，并执行处理，将输出数据写T21入到调用请求中指定的输出数据存储地址中，向从线程b反馈应答响应；

根据调用请求，摄像头1读取第三帧图像数据T3，将读取的数据写入到调用请求中指定的输出数据存储地址中，向从线程c反馈应答响应；

根据调用请求，车辆追踪2在从进程2的共享存储空间中读取输入数据T1、T12，并执行处理，将输出数据T12’写入到调用请求中指定的输出数据存储地址中，向从线程d反馈应答响应；

根据调用请求，车辆检测2在从进程2的共享存储空间中读取输入数据T2，并执行处理，将输出数据T22写入到从进程2的工作存储空间的地址中，向从线程e反馈应答响应；

根据调用请求，摄像头2将读取的数据T3写入到从进程2的工作存储空间的地址中，向从线程f反馈应答响应；

根据调用请求，车辆追踪3在从进程3的共享存储空间中读取输入数据T1、T13，并执行处理，将输出数据T13’写入到从进程3的工作存储空间的地址中，向从线程g反馈应答响应；

根据调用请求，拷贝模块4”’在从进程3的共享存储空间中读取输入数据T15，将读取的数据作为输出数据写入到从进程1的工作存储空间的地址中，向从线程h反馈应答响应；

根据调用请求，车辆检测3在从进程3的共享存储空间中读取输入数据T2，并执行处理，将输出数据T23写入到从进程3的工作存储空间的地址中，向从线程i反馈应答响应；

根据调用请求，分割5在从进程3的共享存储空间中读取输入数据T2，并执行处理，将输出数据T25写入到从进程3的工作存储空间的地址中，向从线程j反馈应答响应；

根据调用请求，摄像头3将读取的第三帧数据T3写入到从进程3的工作存储空间的地址中，向从线程k反馈应答响应；

步骤S23、从线程a接收到应答响应后，将节点3的状态设置为done，并将节点3的输出边3-4、3-3A的状态设置为complete；

从线程b接收到应答响应后，将节点2A的状态设置为done，并将节点 2A的输出边2A-3A的状态设置为complete；

从线程c接收到应答响应后，将节点1B的状态设置为done，并将节点 1B的两个输出边1B-2B、1B-3B的状态设置为complete；

从线程d接收到应答响应后，将节点3’的状态设置为done，并将节点 3’的两个输出边3’-4’、3’-3A’的状态设置为complete；

从线程e接收到应答响应后，将节点2A’的状态设置为done，并将节点 2A’的输出边2A’-3A’的状态设置为complete；

从线程f接收到应答响应后，将节点1B’的状态设置为done，并将节点 1B’的两个输出边1B’-2B’、1B’-3B’的状态设置为complete；

从线程g接收到应答响应后，将节点3”的状态设置为done，并将节点 3”的两个输出边3”-4”、3”-3A”的状态设置为complete；

从进程h接收到应答响应后，将节点4”’的状态设置为done，并将节点 4”’的一个输出边4”’-4的状态设置为complete；

从进程i接收到应答响应后，将节点2A’‘的状态设置为done，并将节点2A”的一个输出边2A”-3A”的状态设置为complete；

从线程j接收到应答响应后，将节点5A的状态设置为done，并将节点 5A的两个输出边5A-4A”’、5A-5B的状态设置为complete；

从线程k接收到应答响应后，将节点1B”的状态设置为done，并将节点1B”的三个输出边1B”-2B”、1B”-3B”、1B”-5B的状态设置为complete；

步骤S24、从线程b将输入边1A-3A、2A-3A、3-3A的状态均为complete 的节点3A的状态修改为ready；

从线程c将输入边1B-2B的状态均为complete的节点2B的状态修改为ready；

从线程d将输入边3’-4’的状态均为complete的节点4’的状态修改为 ready；

从线程e将输入边1A’-3A’、2A’-3A’、3’-3A’的状态均为complete的节点3A’的状态修改为ready；

从线程f将输入边1B’-2B’的状态均为complete的节点2B’的状态修改为ready；

从线程g将输入边3”-4”的状态均为complete的节点4”的状态修改为 ready；

从线程i将输入边1A”-3A”、2A”-3A”、3”-3A”的状态均为complete 的节点3A”的状态修改为ready；

从线程j将输入边5-4”’的状态均为complete的节点4A”’的状态修改为 ready；

从线程k将输入边1B”-2B”的状态均为complete的节点2B”的状态修改为ready，将输入边1B”-5B的状态均为complete的节点5B的状态修改为ready；

步骤S25、从线程b遍历有向计算图中各个节点的状态，将状态为ready 的节点3A的状态设置为run，将节点3A推送到计算队列中；

从线程c遍历有向计算图中各个节点的状态，将状态为ready的节点 2B的状态设置为run，将节点2B推送到计算队列中；

从线程d遍历有向计算图中各个节点的状态，将状态为ready的节点4’的状态设置为run，将节点4’推送到计算队列中；

从线程e遍历有向计算图中各个节点的状态，将状态为ready的节点 3A’的状态设置为run，将节点3A’推送到计算队列中；

从线程f遍历有向计算图中各个节点的状态，将状态为ready的节点2B’的状态设置为run，将节点2B’推送到计算队列中；

从线程g遍历有向计算图中各个节点的状态，将状态为ready的节点4”的状态设置为run，将节点4”推送到计算队列中；

从线程i遍历有向计算图中各个节点的状态，将状态为ready的节点3A”的状态设置为run，将节点3A”推送到计算队列中；

从线程j遍历有向计算图中各个节点的状态，将状态为ready的节点 4A”’的状态设置为run，将节点4A”’推送到计算队列中；

从线程k遍历有向计算图中各个节点的状态，将状态为ready的节点2B”和5B的状态设置为run，将节点2B”和5B推送到计算队列中；

步骤26、从线程a从计算队列中取出节点3A，向节点3A对应的车辆追踪1发送RPC调用请求，在请求中携带输入数据的存储地址和输出数据的存储地址，输入数据地址为摄像头1在从进程1中的共享存储空间中的存储地址R1-S，以及车辆检测1在进程1的共享存储空间中的存储地址 R1-D，输出数据地址为车辆追踪1在进程1的共享存储空间中的存储地址R1-T；

从线程b从计算队列中取出节点2B，向节点2B对应的车辆检测1发送RPC调用请求，在请求中携带输入数据的存储地址和输出数据的存储地址，输入数据地址为摄像头1在从进程1中的共享存储空间中的存储地址 R1-S，输出数据地址为车辆检测1在进程1的共享存储空间中的存储地址 R1-D；

从线程c从计算队列中取出节点4’，向节点4’对应的拷贝模块2发送 RPC调用请求，在请求中携带输入数据的存储地址和输出数据的存储地址，输入数据地址为车辆追踪2在进程2的共享存储空间中的存储地址R2-T，输出数据地址为拷贝模块2在进程1的共享存储空间中的存储地址R1-2C；

从线程d从计算队列中取出节点3A’，向节点3A’对应的车辆追踪2发送RPC调用请求，在请求中携带输入数据的存储地址和输出数据的存储地址，输入数据地址为摄像头2在从进程2中的共享存储空间中的存储地址 R2-S，以及车辆检测2在进程2的共享存储空间中的存储地址R2-D，输出数据地址为车辆追踪2在进程2的共享存储空间中的存储地址R2-T；

从线程e从计算队列中取出节点2B’，向节点2B’对应的车辆检测2发送RPC调用请求，在请求中携带输入数据的存储地址和输出数据的存储地址，输入数据地址为摄像头2在从进程2中的共享存储空间中的存储地址 R2-S，输出数据地址为车辆检测2在进程2的共享存储空间中的存储地址 R2-D；

从线程f从计算队列中取出节点4”，向节点4”对应的拷贝模块3发送 RPC调用请求，在请求中携带输入数据的存储地址和输出数据的存储地址，输入数据地址为车辆追踪3在进程3的共享存储空间中的存储地址R3-T，输出数据地址为拷贝模块3在进程1的共享存储空间中的存储地址R1-3C；

从线程g从计算队列中取出节点3A”，向节点3A”对应的车辆追踪3 发送RPC调用请求，在请求中携带输入数据的存储地址和输出数据的存储地址，输入数据地址为摄像头3在从进程3中的共享存储空间中的存储地址R3-S，以及车辆检测3在进程3的共享存储空间中的存储地址R3-D，输出数据地址为车辆追踪3在进程3的共享存储空间中的存储地址R3-T；

从线程h从计算队列中取出节点4A”’，向节点4A”’对应的拷贝模块4 发送RPC调用请求，在请求中携带输入数据的存储地址和输出数据的存储地址，输入数据地址为分割5在进程3的共享存储空间中的存储地址R3-G，输出数据地址为拷贝模块4在进程3的共享存储空间中的存储地址R1-4C；

从线程i从计算队列中取出节点2B”，向节点2B”对应的车辆检测3 发送RPC调用请求，在请求中携带输入数据的存储地址和输出数据的存储地址，输入数据地址为摄像头3在从进程3中的共享存储空间中的存储地址R3-S，输出数据地址为车辆检测3在进程3的共享存储空间中的存储地址R3-D；

从线程j从计算队列中取出节点5B，向节点5B对应的分割5发送RPC 调用请求，在请求中携带输入数据的存储地址和输出数据的存储地址，输入数据地址为摄像头3在从进程3中的共享存储空间中的存储地址R3-S，输出数据地址为分割5在进程3的共享存储空间中的存储地址R3-G；

步骤S27、根据调用请求，车辆追踪1在从进程1的共享存储空间中读取输入数据T2、T21，并执行处理，将输出数据T21’写入到从进程1的工作存储空间的地址中，向从线程a反馈应答响应；

根据调用请求，车辆检测1在从进程1的共享存储空间中读取输入数据T3，并执行处理，将输出数据写T31入到从进程1的工作存储空间的地址中，向从线程b反馈应答响应；

根据调用请求，拷贝模块2在从进程2的共享存储空间中读取输入数据T12’，将输出数据T12’写入到从进程1的工作存储空间的地址中，向从线程c反馈应答响应；

根据调用请求，车辆追踪2在从进程2的共享存储空间中读取输入数据T2、T22，并执行处理，将输出数据T22’写入到从进程2的工作存储空间的地址中，向从线程d反馈应答响应；

根据调用请求，车辆检测2在从进程2的共享存储空间中读取输入数据T3，并执行处理，将输出数据T32写入到从进程2的工作存储空间的地址中，向从线程e反馈应答响应；

根据调用请求，拷贝模块3在从进程3的共享存储空间中读取输入数据T13’，将读取的数据作为输出数据写入到从进程1的工作存储空间的地址中，向从线程f反馈应答响应；

根据调用请求，车辆追踪3在从进程3的共享存储空间中读取输入数据T2、T23，并执行处理，将输出数据T23’写入到从进程3的工作存储空间的地址中，向从线程g反馈应答响应；

根据调用请求，拷贝模块4在从进程3的共享存储空间中读取输入数据T25，并执行处理，将读取的数据作为输出数据写入到从进程1的工作存储空间的地址中，向从线程h反馈应答响应；

根据调用请求，车辆检测3在从进程3的共享存储空间中读取输入数据T3，并执行处理，将输出数据T33写入到从进程3的工作存储空间的地址中，向从线程i反馈应答响应；

根据调用请求，分割5在从进程3的共享存储空间中读取输入数据T3，并执行处理，将输出数据T35写入到从进程3的工作存储空间的地址中，向从线程j反馈应答响应；

步骤S28、从线程a接收到应答响应后，将节点3A的状态设置为done，并将节点3A的两个输出边3A-4A、3A-3B的状态设置为complete；

从线程b接收到应答响应后，将节点2B的状态设置为done，并将节点 2B的一个输出边2B-3B的状态设置为complete；

从线程c接收到应答响应后，将节点4’的状态设置为done，并将节点 4’的一个输出边4’-4的状态设置为complete；

从线程d接收到应答响应后，将节点3A’的状态设置为done，并将节点 3A’的两个输出边3A’-4A’、3A’-3B’的状态设置为complete；

从线程e接收到应答响应后，将节点2B’的状态设置为done，并将节点 2B’的输出边2B’-3B’的状态设置为complete；

从线程f接收到应答响应后，将节点4”的状态设置为done，并将节点 4”的输出边4”-4的状态设置为complete；

从线程g接收到应答响应后，将节点3A”的状态设置为done，并将节点3A”的输出边3A”-4A”、3A”-3B”的状态设置为complete；

从线程h接收到应答响应后，将节点4A”’的状态设置为done，并将节点4A”’的输出边4A”’-4A的状态设置为complete；

从线程i接收到应答响应后，将节点2B”的状态设置为done，并将节点2B”的输出边2B”-3B”的状态设置为complete；

从线程j接收到应答响应后，将节点5B的状态设置为done，并将节点 5B的输出边5B-4B”’的状态设置为complete；

步骤S29、从线程b将全部输入边1B-3B、2B-3B、3A-3B的状态均为 complete的节点3B的状态修改为ready；

从线程d将全部输入边3A’-4A’的状态均为complete的节点4A’的状态修改为ready；

从线程e将全部输入边1B’-3B’、2B’-3B’、3A’-3B’的状态均为complete 的节点3B’的状态修改为ready；

从线程f将全部输入边3-4、4’-4、4”-4、4”’-4的状态均为complete的节点4的状态修改为ready；

从线程g将全部输入边3A”-4A”的状态均为complete的节点4A”的状态修改为ready；

从线程i将全部输入边1B”-3B”、2B”-3B”、3A”-3B”的状态均为 complete的节点3B”的状态修改为ready；

从线程j将全部输入边5B”-4B”’的状态均为complete的节点4B”’的状态修改为ready；

步骤S30、从线程b遍历有向计算图中各个节点的状态，将状态为ready 的节点3B的状态设置为run，将节点3B推送到计算队列中；

从线程d遍历有向计算图中各个节点的状态，将状态为ready的节点 4A’的状态设置为run，将节点4A’推送到计算队列中；

从线程e遍历有向计算图中各个节点的状态，将状态为ready的节点 3B’的状态设置为run，将节点3B’推送到计算队列中；

从线程f遍历有向计算图中各个节点的状态，将状态为ready的节点4 的状态设置为run，将节点4推送到计算队列中；

从线程g遍历有向计算图中各个节点的状态，将状态为ready的节点 4A”的状态设置为run，将节点4A”推送到计算队列中；

从线程i遍历有向计算图中各个节点的状态，将状态为ready的节点3B”的状态设置为run，将节点3B”推送到计算队列中；

从线程j遍历有向计算图中各个节点的状态，将状态为ready的节点 4B”’的状态设置为run，将节点4B”’推送到计算队列中；

步骤S31、从线程b从计算队列中取出节点3B，向节点3B对应的车辆追踪1发送RPC调用请求，在请求中携带输入数据的存储地址和输出数据的存储地址，输入数据地址为摄像头1在从进程1的共享存储空间中的存储地址R1-S、车辆检测1在从进程1的共享存储空间中的存储地址R1-D，输出数据地址为车辆追踪1在从进程1的共享存储空间中的存储地址R1-T；

从线程c从计算队列中取出节点4A’，向节点4A’对应的拷贝模块2发送RPC调用请求，在请求中携带输入数据的存储地址和输出数据的存储地址，输入数据地址为车辆追踪2在从进程2的共享存储空间中的存储地址 R2-T，输出数据地址为拷贝模块2在从进程1的共享存储空间中的存储地址R1-2C；

从线程d从计算队列中取出节点3B’，向节点3B’对应的车辆追踪2发送RPC调用请求，在请求中携带输入数据的存储地址和输出数据的存储地址，输入数据地址为摄像头2在从进程2的共享存储空间中的存储地址 R2-S、车辆检测2在从进程2的共享存储空间中的存储地址R2-D，输出数据地址为车辆追踪2在从进程2的共享存储空间中的存储地址R2-T；

从线程e从计算队列中取出节点4，向节点4对应的融合4发送RPC 调用请求，在请求中携带输入数据的存储地址，输入数据地址为车辆追踪1 在从进程1的共享存储空间中的存储地址R1-T、拷贝模块2在从进程1的共享存储空间中的存储地址R1-2C、拷贝模块3在从进程1的共享存储空间中的存储地址R1-3C、拷贝模块4在从进程1的共享存储空间中的存储地址 R1-4C；

从线程f从计算队列中取出节点4A”，向节点4A”对应的拷贝模块3发送RPC调用请求，在请求中携带输入数据的存储地址，输入数据地址为车辆追踪3在从进程3的共享存储空间中的存储地址R3-T，输出数据地址为拷贝模块3在从进程1的共享存储空间中的存储地址R1-3C；

从线程g从计算队列中取出节点3B”，向节点3B”对应的车辆追踪3 发送RPC调用请求，在请求中携带输入数据的存储地址和输出数据的存储地址，输入数据地址为摄像头3在从进程3的共享存储空间中的存储地址 R3-S、车辆检测3在从进程3的共享存储空间中的存储地址R3-D，输出数据地址为车辆追踪3在从进程3的共享存储空间中的存储地址R3-T；

从线程h从计算队列中取出节点4B”’，向节点4B”’对应的拷贝模块4 发送RPC调用请求，在请求中携带输入数据的存储地址和输出数据的存储地址，输入数据地址为分割5在从进程3的共享存储空间中的存储地址 R3-G，输出数据地址为车拷贝模块4在从进程1的共享存储空间中的存储地址R1-4C；

步骤S32、根据调用请求，车辆追踪1在从进程1的共享存储空间中读取输入数据T3、T31，并执行处理，将输出数据T31’写入到调用请求中指定的输出数据存储地址中，向从线程b反馈应答响应；

根据调用请求，拷贝模块2在从进程2的共享存储空间中读取输入数据T22’，将输出数据T22’写入到调用请求中指定的输出数据存储地址中，向从线程c反馈应答响应；

根据调用请求，车辆追踪2在从进程2的共享存储空间中读取输入数据T3、T32，并执行处理，将输出数据T32’写入到调用请求中指定的输出数据存储地址中，向从线程d反馈应答响应；

根据调用请求，融合4在从进程1的共享存储空间中读取输入数据 T11’、T12’、T13’、T15，并执行处理，将输出数据写入到调用请求中指定的输出数据存储地址中，向从线程e反馈应答响应；

根据调用请求，拷贝模块3在从进程3的共享存储空间中读取输入数据T23’，将输出数据T23’写入到调用请求中指定的输出数据存储地址中，向从线程f反馈应答响应；

根据调用请求，车辆追踪3在从进程3的共享存储空间中读取输入数据T3、T33，并执行处理，将输出数据T33’写入到调用请求中指定的输出数据存储地址中，向从线程g反馈应答响应；

根据调用请求，拷贝模块4在从进程3的共享存储空间中读取输入数据T35，将输出数据T35写入到调用请求中指定的输出数据存储地址中，向从线程h反馈应答响应；

步骤S33、从线程b接收到应答响应后，将节点3B的状态设置为done；并将节点3B的输出边3B-4B、3B-3的状态设置为complete；

从线程c接收到应答响应后，将节点4A’的状态设置为done；并将节点 4A’的输出边4A’-4A的状态设置为complete；

从线程d接收到应答响应后，将节点3B’的状态设置为done；并将节点3B’的输出边3B’-4B’、3B’-3’的状态设置为complete；

从线程e接收到应答响应后，将节点4的状态设置为done；并将节点4 的输出边4-4A的状态设置为complete；

并且，从线程e遍历子图1，确定子图1中的全部节点的状态都为done，将控制队列头部的存储空间1释放掉，此时，控制队列的头部转变为子图2 所在的存储空间2，释放掉的存储空间1转变为控制队列的队尾；从线程e 向主线程发送通知(Notify)，主线程接收到Notify后，执行上述步骤S2， S5-10，即将一个有向计算图即子图4(图10中未示出)存储到控制队列尾部，并建立子图3中对应串行模块的节点至子图4中相应节点的输出边；主线程对新存入的子图4中的节点和连接线的状态进行初始化，具体处理包括：由于节点1B、1B’、1B”均已执行完成、状态为done，节点1、1’、 1”的输入边为complete，将子图4中的起始节点节点1、节点1’、节点1”的状态设置为ready，其它节点的状态设置为unready，将所有连接边的状态设置为uncomplete；主线程将节点1、节点1’、节点1”的状态修改为run，并将节点1、节点1’、节点1”推送到计算队列中；并且主线程返回步骤S2，并进行到步骤S3；

从线程f接收到应答响应后，将节点4A”的状态设置为done；并将节点4A”的输出边4A”-4A的状态设置为complete；

从线程g接收到应答响应后，将节点3B”的状态设置为done；并将节点3B”的输出边3B”-4B”、3B”-3”的状态设置为complete；

从线程h接收到应答响应后，将节点4B”’的状态设置为done；并将节点4B”’的输出边4B”’-4B的状态设置为complete；

步骤S34、从线程d将全部输入边3B’-4B’的状态均为complete的节点 4B’的状态修改为ready；

从线程f将全部输入边4A”-4A的状态均为complete的节点4A的状态修改为ready；

从线程g将全部输入边3B”-4B”的状态均为complete的节点4B”的状态修改为ready；

步骤S35、从线程d将遍历有向计算图中各个节点的状态，将状态为 ready的节点4B’的状态设置为run，将节点4B’推送到计算队列中；

从线程f将遍历有向计算图中各个节点的状态，将状态为ready的节点 4A的状态设置为run，将节点4A推送到计算队列中；

从线程g将遍历有向计算图中各个节点的状态，将状态为ready的节点 4B”的状态设置为run，将节点4B”推送到计算队列中；

步骤S36、从线程a从计算队列中取出节点1，向节点1对应的计算模块摄像头1发送RPC调用请求，在请求中携带输出数据的存储地址，也即摄像头1在从进程1的共享存储空间中的存储地址R1-S；

从线程b从计算队列中取出节点1’，向节点1’对应的模块摄像头2发送RPC调用请求，在请求中携带输出数据的存储地址，也即摄像头2在从进程2的共享存储空间中的存储地址R2-S；

从线程c从计算队列中取出节点1”，向节点1”对应的模块摄像头3发送RPC调用请求，在请求中携带输出数据的存储地址，也即摄像头3在从进程3的共享存储空间中的存储地址R3-S；

从线程d从计算队列中取出节点4B’，向节点4B’对应的拷贝模块2发送RPC调用请求，在请求中携带输入数据的存储地址和输出数据的存储地址，输入数据地址为车辆追踪2在从进程2的共享存储空间中的存储地址 R2-T，输出数据地址为拷贝模块2在从进程1的共享存储空间中的存储地址R1-2C；

从线程e从计算队列中取出节点4A，向节点4A对应的融合4发送RPC 调用请求，在请求中携带输入数据的存储地址，输入数据地址为车辆追踪1 在从进程1的共享存储空间中的存储地址R1-T、拷贝模块2在从进程1中的共享存储空间中的存储地址R1-2C、拷贝模块3在从进程1中的共享存储空间中的存储地址R1-3C、拷贝模块4在从进程1中的共享存储空间中的存储地址R1-4C；

从线程f从计算队列中取出节点4B”，向节点4B”对应的拷贝模块3 发送RPC调用请求，在请求中携带输入数据的存储地址和输出数据的存储地址，输入数据地址为车辆追踪3在从进程3的共享存储空间中的存储地址R3-T，输出数据地址为拷贝模块3在从进程1的共享存储空间中的存储地址R1-3C；

步骤S37、根据调用请求，摄像头1将读取到的第四帧图像数据T4写入到从进程1的工作存储空间的地址中，向从线程a反馈应答响应；

根据调用请求，摄像头2将读取到的第四帧图像数据T4写入到从进程 2的工作存储空间的地址中，向从线程b反馈应答响应；

根据调用请求，摄像头3将读取到的第四帧图像数据T4写入到从进程 3的工作存储空间的地址中，向从线程c反馈应答响应；

根据调用请求，拷贝模块2在从进程2的共享存储空间中读取输入数据T32’，将输出数据T32’写入到调用请求中指定的输出数据存储地址中，向从线程d反馈应答响应；

根据调用请求，融合4在从进程1的共享存储空间中读取输入数据 T21’、T22’、T23’、T25，并执行处理，输出得到的处理结果，向从线程e 反馈应答响应；

根据调用请求，拷贝模块3在从进程3的共享存储空间中读取输入数据T33’，并执行处理，将输出数据T33’写入到调用请求中指定的输出数据存储地址中，向从线程f反馈应答响应；

步骤S38、从线程a接收到应答响应后，将节点1的状态设置为done；并将节点1的输出边1-2、1-3、1-1A的状态设置为complete；

从线程b接收到应答响应后，将节点1’的状态设置为done；并将节点1’的输出边1’-2’、1’-3’、1’-1A’的状态设置为complete；

从线程c接收到应答响应后，将节点1”的状态设置为done；并将节点 1”的输出边1”-2”、1”-3”、1”-5、1”-1A”的状态设置为complete；

从线程d接收到应答响应后，将节点4B’的状态设置为done；并将节点4B’的输出边4B’-4B的状态设置为complete；

从线程e接收到应答响应后，将节点4A的状态设置为done；并将节点 4A的输出边4A-4B的状态设置为complete；

并且，从线程e遍历子图2，确定子图2中的全部节点的状态都为done，将控制队列头部的存储空间2释放掉，此时，控制队列的头部转变为子图3 所在的存储空间3，释放掉的存储空间2转变为控制队列的队尾；从线程e 向主线程发送通知(Notify)，主线程接收到Notify后，执行上述步骤S2， S5-10，即将一个有向计算图即子图5(图10中未示出)存储到控制队列尾部，并建立子图4中对应串行模块的节点至子图5中相应节点的输出边；主线程对子图2中的节点和连接线的状态进行初始化，具体处理包括：由于节点1、1’、1”的状态为done，节点1A、节点1A’、节点1A”的输入边均为complete，将子图5中的起始节点节点1A、节点1A’、节点1A”的状态设置为ready，其它节点的状态设置为unready，将所有连接边的状态设置为uncomplete；主线程将节点1A、节点1A’、节点1A”的状态修改为run，并将节点1A、节点1A’、节点1A”推送到计算队列中；主线程返回步骤S2，并进行到步骤S3；

从线程f接收到应答响应后，将节点4B”的状态设置为done；并将节点4B”的输出边4B”-4B的状态设置为complete；

步骤S39、从线程a将输入边的状态为complete的节点2的状态修改为ready；

从线程b将输入边的状态为complete的节点2’的状态修改为ready；

从线程c将输入边的状态为complete的节点2”、5的状态修改为ready；

从线程f将输入边的状态为complete的节点4B的状态修改为ready；

步骤S40、从线程a遍历有向计算图中各个节点的状态，将状态为ready 的节点2的状态设置为run，将节点2推送到计算队列中；

从线程b遍历有向计算图中各个节点的状态，将状态为ready的节点2’的状态设置为run，将节点2’推送到计算队列中；

从线程c遍历有向计算图中各个节点的状态，将状态为ready的节点2”、 5的状态设置为run，将节点2”、5推送到计算队列中；

从线程f遍历有向计算图中各个节点的状态，将状态为ready的节点4B 的状态设置为run，将节点4B推送到计算队列中；

步骤S41、从线程a从计算队列中取出从计算队列中取出节点2，向节点2对应的模块车辆检测1发送RPC调用请求，在请求中携带输入数据的存储地址和输出数据的存储地址，输入数据地址为摄像头1在从进程1的共享存储空间中的存储地址R1-S，输出数据地址为车辆检测1在从进程1 的共享存储空间中的存储地址R1-D；

从线程b从计算队列中取出节点2’，向节点2’对应的模块车辆检测2 发送RPC调用请求，在请求中携带输入数据的存储地址和输出数据的存储地址，输入数据地址为摄像头2在从进程2的共享存储空间中的存储地址 R2-S，输出数据地址为车辆检测2在从进程2的共享存储空间中的存储地址R2-D；

从线程c从计算队列中取出节点2”，向节点2”对应的模块车辆检测3 发送RPC调用请求，在请求中携带输入数据的存储地址和输出数据的存储地址，输入数据地址为摄像头3在进程3的共享存储空间中的存储地址 R3-S，输出数据地址为车辆检测3在进程3的共享存储空间中的存储地址 R3-D；

从线程d从计算队列中取出节点5，向节点5对应的分割模块发送RPC 调用请求，在请求中携带输入数据的存储地址和输出数据的存储地址，输入数据地址为摄像头3在进程3的共享存储空间中的存储地址R3-S，输出数据地址为分割模块在进程3的共享存储空间中的存储地址R3-G；

从线程e从计算队列中取出从计算队列中取出节点1A，向节点1A对应的模块摄像头1发送RPC调用请求，在请求中携带输出数据的存储地址，输出数据地址为摄像头1在进程1的共享存储空间中的存储地址R1-S；

从线程f从计算队列中取出从计算队列中取出节点1A’，向节点1A’对应的模块摄像头2发送RPC调用请求，在请求中携带输出数据的存储地址，输出数据地址为摄像头2在从进程2的共享存储空间中的存储地址R2-S；

从线程g从计算队列中取出从计算队列中取出节点1A”，向节点1A”对应的模块摄像头3发送RPC调用请求，在请求中携带输出数据的存储地址，输出数据地址为摄像头3在从进程3中的共享存储空间中的存储地址 R3-S；

从线程h从计算队列中取出节点4B，向节点4B对应的计算模块融合4 发送RPC调用请求，在请求中携带输入数据的存储地址，也即车辆追踪1 在从进程1的共享存储空间中的存储地址R1-T、拷贝模块2在从进程1的共享存储空间中的存储地址R1-2C、拷贝模块3在从进程1的共享存储空间中的存储地址R1-3C、拷贝模块4在从进程1的共享存储空间中的存储地址 R1-4C；

步骤S42、根据调用请求，车辆检测1在从进程1的共享存储空间中读取输入数据T4，并执行处理，将输出数据T41写入到调用请求中指定的输出数据存储地址中，向从线程a反馈应答响应；

根据调用请求，车辆检测2在从进程2的共享存储空间中读取输入数据T4，并执行处理，将输出数据T42入到调用请求中指定的输出数据存储地址中，向从线程b反馈应答响应；

根据调用请求，车辆检测3在从进程3的共享存储空间中读取输入数据T4，并执行处理，将输出数据T43写入到调用请求中指定的输出数据存储地址中，向从线程c反馈应答响应；

根据调用请求，分割模块5在从进程3的共享存储空间中读取输入数据T4，并执行处理，将输出数据T45写入到调用请求中指定的输出数据存储地址中，向从线程d反馈应答响应；

根据调用请求，摄像头1将读取到的第五帧图像数据T5写入到调用请求中指定的输出数据存储地址中，向从线程e反馈应答响应；

根据调用请求，摄像头2将获取的第五帧图像数据T5写入到调用请求中指定的输出数据存储地址中，向从线程f反馈应答响应；

根据调用请求，摄像头3将获取的第五帧图像数据T5写入到调用请求中指定的输出数据存储地址中，向从线程g反馈应答响应；

根据调用请求，融合4在从进程1的共享存储空间中读取输入数据 T31’、T32’、T33’、T35，并执行处理，输出处理得到的结果，向从线程h 反馈应答响应；

步骤S43、从线程a接收到应答响应后，将节点2的状态设置为done，并将节点2的输出边2-3的状态设置为complete；

从线程b接收到应答响应后，将节点2’的状态设置为done，并将节点 2’的输出边2’-3’的状态设置为complete；

从线程c接收到应答响应后，将节点2”的状态设置为done，并将节点 2”的输出边2”-3”的状态设置为complete；

从线程d接收到应答响应后，将节点5的状态设置为done，并将节点 5的输出边5-4”’、5-5A的状态设置为complete；

从线程e接收到应答响应后，将节点1A的状态设置为done，并将节点 1A的输出边1A-2A、1A-3A、1A-1B的状态设置为complete；

从线程f接收到应答响应后，将节点1A’的状态设置为done，并将节点 1A’的输出边1A’-2A’、1A’-3A’、1A’-1B’的状态设置为complete；

从线程g接收到应答响应后，将节点1A”的状态设置为done，并将节点1A”的输出边1A”-2A”、1A”-3A”、1A”-1B”的状态设置为complete；

从线程h接收到应答响应后，将节点4B的状态设置为done，并将节点 4B的输出边4B-4的状态设置为complete；

并且，从线程h遍历子图3，确定子图3中的全部节点的状态都为done，将控制队列头部的存储空间2释放掉，此时，控制队列的头部转变为子图3 所在的存储空间3，释放掉的存储空间2转变为控制队列的队尾，从线程h 向主线程发送通知(Notify)，主线程接收到Notify后，执行上述步骤S2、 S5-9，即将一个有向计算图即子图6(图10中未示出)存储到控制队列尾部，并建立子图5中对应串行模块的节点至子图6中相应节点的输出边；主线程对新存入的子图6中的节点和连接线的状态进行初始化，具体处理包括：节点1A、1A’、1A”的状态为done，节点1B、节点1B’、节点1B”的输入边为complete，将子图3中的起始节点节点1B、节点1B’、节点1B”的状态设置为ready，其它节点的状态设置为unready，将所有连接边的状态设置为uncomplete；主线程将节点1B、节点1B’、节点1B”的状态修改为run，并将节点1B、节点1B’、节点1B”推送到计算队列中；主线程返回步骤S2，并进行到步骤S3。至此，有向计算图中3个子图的状态都更新了一遍。以下其它从进程的处理与前面的处理类似，这里省略说明。

通过上述处理过程可以看出，主进程根据有向计算图来控制从进程中所有计算模块的计算逻辑，即主进程通过RPC调用来控制计算模块的执行，并且根据模块执行的情况来维护与模块对应的节点的状态，以及节点的输出的状态；在一个节点的多个输入边的状态均为完成的情况下，才能调用执行与节点对应的计算模块，在收到应当响应的情况下，更新该节点的状态和该节点的输出边的状态，从而能够控制保证计算模块的输入数据的一致性。

进一步，从进程中还具有一个对应的共享存储空间，共享存储空间中包括与进程中的每个计算模块相对应的存储空间，计算模块之间不再通过进程之间的通信机制进行数据传输，而是通过进程内共享的存储空间来进行数据的读取和写入，从而能够提高计算模块之间的通信效率，降低通信延时，提高多模块之间整体的通信效率，提高系统吞吐量。

更进一步，主线程在控制队列中的多个存储空间中分别存入有向计算图，在有向计算图之间，建立相邻的前一个有向计算图中对应串行模块的节点至后一个有向计算图该相同节点的输出边，也即对串行模块进行调度时，需要根据前一个有向计算图中节点对应的串行模块的执行情况来调度串行模型的执行，而并行模块并不具有这样的约束，从而并行模块能够执行并行处理，提高处理速度。

以上结合具体实施例描述了本发明的基本原理，但是，需要指出的是，对本领域普通技术人员而言，能够理解本发明的方法和装置的全部或者任何步骤或者部件可以在任何计算装置(包括处理器、存储介质等)或者计算装置的网络中，以硬件固件、软件或者他们的组合加以实现，这是本领域普通技术人员在阅读了本发明的说明的情况下运用它们的基本编程技能就能实现的。

显然，本领域的技术人员可以对本发明进行各种改动和变型而不脱离本发明的精神和范围。这样，倘若本发明的这些修改和变型属于本发明权利要求及其等同技术的范围之内，则本发明也意图包含这些改动和变型在内。

Claims (38)

1.一种多模块调度方法，其特征在于，包括：

主进程读取预存的配置文件，配置文件中保存有一个有向计算图；其中，有向计算图与一个计算任务相对应，计算任务包括多个从进程，每个从进程包括按照计算方向组合的多个计算模块；有向计算图中包括多个节点，每个节点对应一个从进程中的一个计算模块，节点之间具有连接边，进入节点的连接边为输入边，离开节点的连接边为输出边；

在当前计算周期中，主进程初始化节点和连接边的状态；

根据有向计算图的计算方向以及节点的状态确定待调用节点，其中，待调用节点包括节点的多个输入边均为完成状态的节点；

向待调用节点对应的从进程中的计算模块发送远程过程调用(RPC)的调用请求以执行该计算模块；

在收到针对调用请求的应答响应后，更新该节点的状态和该节点的输出边的状态；

在确定有向计算图的全部节点的状态更新结束后，进行下一个计算周期的处理。

2.根据权利要求1所述的方法，其特征在于，主进程包括主线程和线程池，线程池中包括多个从线程；

节点的状态包括：未就绪(unready)、就绪(ready)、运行(run)和结束(done)；

连接边的状态包括：未完成(uncomplete)和完成(complete)。

3.根据权利要求2所述的方法，其特征在于，从进程中的计算模块包括并行计算模块和串行计算模块；则，

主进程初始化节点和连接边的状态，包括：

主线程根据预定时间间隔判断控制队列中是否有空闲存储空间，在判断为否的情况下，主线程将自身的状态设置为等待(wait)，在判断为是的情况下，将一个有向计算图存入到一个控制队列的空闲存储空间中；

在控制队列中存储有多个有向计算图的情况下，按照队列方向，建立第i-1个存储空间中的有向计算图中与串行模块对应的节点至第i个存储空间中有向计算图的相同节点的输出边；2≤i≤n，n为控制队列中存储空间的数量，n为自然数；

初始化控制队列中新存入的有向计算图中节点和连接边的状态。

4.根据权利要求3所述的方法，其特征在于，初始化控制队列中新存入的有向计算图中节点和连接边的状态，包括：

主线程判断新存入的有向计算图是否是控制队列中存储的第一个有向计算图；

在判断为是的情况下，将该有向计算图的起始节点设置为ready，将该有向计算图中的其它全部节点的状态设置为unready，将该有向计算图的全部连接边设置为uncomplete；

在判断为否的情况下，对于与该有向计算图相邻的上一个有向计算图的节点连接至该有向计算图的相同节点连接边，在相邻的上一个有向计算图的相同节点的状态为done的情况下，将该连接边的状态设置为complete，否则，将该连接边的状态设置为uncomplete；并且，将该有向计算图中节点的输入边均为complete的节点设置为ready，将其它全部节点的状态设置为unready，将该有向计算图的全部连接边设置为uncomplete。

5.根据权利要求3所述的方法，其特征在于，根据有向计算图的计算方向以及节点的状态确定待调用节点，包括：

主线程在初始化控制队列中新存入的有向计算图中节点和连接边的状态后，根据计算方向遍历控制队列中各有向计算图中的各个节点的状态，将状态为ready的节点确定为待调用节点，其中，状态为ready的节点包括节点的多个输入边均为complete状态的节点；将待调用节点的状态修改为run，并将待调用节点推送到计算队列中，并且主线程进行进入等待状态；或者，

在计算过程中，线程池中的一个从线程根据计算方向遍历控制队列中各有向计算图中的各个节点的状态，将状态为ready的节点确定为待调用节点，其中，状态为ready的节点包括节点的多个输入边均为complete状态的节点；将待调用节点的状态修改为run，并将待调用节点推送到计算队列中。

6.根据权利要求5所述的方法，其特征在于，向待调用的节点对应的从进程中的计算模块发送RPC的调用请求以执行该计算模块，包括：

线程池中的一个从线程从计算队列中取出一个节点，向该节点对应的从进程中的计算模块发送RPC的调用请求。

7.根据权利要求6所述的方法，其特征在于，所述方法还包括：

根据预存的配置文件，线程池中的一个从线程确定从计算队列中取出的节点所对应的计算模块的标识、以及计算模块的输入数据的存储地址和/或输出数据的存储地址，将该计算模块的标识、输入数据的存储地址和/或输出数据的存储地址携带在调用请求中。

8.根据权利要求7所述的方法，其特征在于，计算模块的输出数据的存储地址是计算模块所在的从进程所对应的共享存储空间中的地址，该地址与计算模块相对应；或者，输出数据的存储地址是另一个从进程所应对的共享存储空间中的地址，该地址与计算模块相对应；

计算模块的输入数据的存储地址是计算模块所在的从进程所对应的共享存储空间中的地址。

9.根据权利要求2所述的方法，其特征在于，在收到针对调用请求的应答响应后，更新该节点的状态和该节点的输出边的状态，包括：

线程池中的一个从线程在收到针对一个节点所发出的调用请求的应答响应后，将该节点的状态设置为done，将该节点的输出边的状态修改为complete，并且将所有输入边均为complete的节点的状态设置为ready。

10.根据权利要求3所述的方法，其特征在于，在确定有向计算图的全部节点的状态更新结束后，进行下一个计算周期的处理，包括：

线程池中的一个从线程遍历控制队列头部的有向计算图中的各个节点的状态，在确定该有向计算图中所有节点的状态为done的情况下，释放控制队列头部的存储空间，并向处于等待状态的主线程发送通知(Notify)，以使主线程进行下一个计算周期的处理。

11.一种多模块调度方法，其特征在于，包括：

在当前计算周期中，从进程中的一个计算模块接收来自主进程的远程过程调用(RPC)的调用请求；其中，从进程中包括根据计算方向组合的多个计算模块；对于具有多个输入数据的计算模块，调用请求是主进程在确定计算模块的多个输入数据都已就绪的情况下发出的；

该计算模块响应于调用请求执行处理；

在处理执行完成后，计算模块向主进程反馈应答响应。

12.根据权利要求11所述的方法，其特征在于，所述方法还包括：接收到的调用请求中包括计算模块的标识、输入数据的存储地址和/或输出数据的存储地址；

则，计算模块响应于调用请求执行处理，包括：

计算模块响应于调用请求，从输入数据的存储地址读取输入数据执行处理，并将输出数据写入到输出数据的存储地址中。

13.根据权利要求12所述的方法，其特征在于，输出数据的存储地址是从进程所对应的共享存储空间中的地址，该地址与计算模块相对应；

或者，输出数据的存储地址是另一个从进程所应对的共享存储空间中的地址，该地址与计算模块相对应。

14.根据权利要求12所述的方法，其特征在于，输入数据的存储地址是从进程所对应的共享存储空间中的地址。

15.根据权利要求11所述的方法，其特征在于，计算模块是一个服务(Service)函数。

16.一种多模块调度装置，其特征在于，包括：

读取模块，用于读取预存的配置文件，配置文件中保存有一个有向计算图；其中，有向计算图与一个计算任务相对应，计算任务包括多个从进程，每个从进程包括按照计算方向组合的多个计算模块；有向计算图中包括多个节点，每个节点对应一个从进程中的一个计算模块，节点之间具有连接边，进入节点的连接边为输入边，离开节点的连接边为输出边；

执行模块，用于在当前计算周期中初始化节点和连接边的状态；根据有向计算图的计算方向以及节点的状态确定待调用节点，其中，待调用节点包括节点的多个输入边均为完成状态的节点；向待调用的节点对应的从进程中的计算模块发送远程过程调用(RPC)的调用请求以执行该计算模块；在收到针对调用请求的应答响应后，更新该节点的状态和该节点的输出边的状态；在确定有向计算图的全部节点的状态更新结束后，进行下一个计算周期的处理。

17.根据权利要求16所述的装置，其特征在于，执行模块包括主线程模块和线程池模块，线程池模块中包括多个从线程模块；

节点的状态包括：未就绪(unready)、就绪(ready)、运行(run)和结束(done)；

连接边的状态包括：未完成(uncomplete)和完成(complete)。

18.根据权利要求17所述的装置，其特征在于，从进程中的计算模块包括并行计算模块和串行计算模块；则，

执行模块初始化节点和连接边的状态，包括：

主线程模块根据预定时间间隔判断控制队列中是否有空闲存储空间，在判断为否的情况下，主线程模块将自身的状态设置为等待(wait)，在判断为是的情况下，将一个有向计算图存入到一个控制队列的空闲存储空间中；

在控制队列中存储有多个有向计算图的情况下，按照队列方向，建立第i-1个存储空间中的有向计算图中与串行模块对应的节点至第i个存储空间中有向计算图的相同节点的输出边；2≤i≤n，n为控制队列中存储空间的数量，n为自然数；

初始化控制队列中新存入的有向计算图中节点和连接边的状态。

19.根据权利要求18所述的装置，其特征在于，主线程模块初始化控制队列中新存入的有向计算图中节点和连接边的状态，包括：

主线程模块判断新存入的有向计算图是否是控制队列中存储的第一个有向计算图；

在判断为是的情况下，将该有向计算图的起始节点设置为ready，将该有向计算图中的其它全部节点的状态设置为unready，将该有向计算图的全部连接边设置为uncomplete；

在判断为否的情况下，对于与该有向计算图相邻的上一个有向计算图的节点连接至该有向计算图的相同节点连接边，在相邻的上一个有向计算图的相同节点的状态为done的情况下，将该连接边的状态设置为complete，否则，将该连接边的状态设置为uncomplete；并且，将该有向计算图中节点的输入边均为complete的节点设置为ready，将其它全部节点的状态设置为unready，将该有向计算图的全部连接边设置为uncomplete。

20.根据权利要求18所述的装置，其特征在于，执行模块根据有向计算图的计算方向以及节点的状态确定待调用节点，包括：

主线程模块在初始化控制队列中新存入的有向计算图中节点和连接边的状态后，根据计算方向遍历控制队列中各有向计算图中的各个节点的状态，将状态为ready的节点确定为待调用节点，其中，状态为ready的节点包括节点的多个输入边均为complete状态的节点；将待调用节点的状态修改为run，并待调用节点推送到计算队列中，并且主线程模块进入等待状态；或者，

在计算过程中，线程池模块中的一个从线程模块根据计算方向遍历控制队列中各有向计算图中的各个节点的状态，将状态为ready的节点确定为待调用节点，其中，状态为ready的节点包括节点的多个输入边均为complete状态的节点，将待调用节点的状态修改为run，并待调用节点推送到计算队列中。

21.根据权利要求20所述的装置，其特征在于，执行模块向待调用的节点对应的从进程中的计算模块发送RPC的调用请求以执行该计算模块，包括：

线程池模块中的一个从线程模块从计算队列中取出一个节点，向该节点对应的从进程中的计算模块发送RPC的调用请求。

22.根据权利要求21所述的装置，其特征在于，从线程模块还用于：

根据预存的配置文件，确定从计算队列中取出的节点所对应的计算模块的标识、以及计算模块的输入数据的存储地址和/或输出数据的存储地址，将该计算模块的标识、输入数据的存储地址和/或输出数据的存储地址携带在调用请求中；

其中，计算模块的输出数据的存储地址是计算模块所在的从进程所对应的共享存储空间中的地址，该地址与计算模块相对应；或者，输出数据的存储地址是另一个从进程所应对的共享存储空间中的地址，该地址与计算模块相对应；

计算模块的输入数据的存储地址是计算模块所在的从进程所对应的共享存储空间中的地址。

23.根据权利要求17所述的装置，其特征在于，执行模块在收到针对调用请求的应答响应后，更新该节点的状态和该节点的输出边的状态，包括：

线程池模块中的一个从线程模块在收到针对一个节点所发出的调用请求的应答响应后，将该节点的状态设置为done，将该节点的输出边的状态修改为complete，并且将所有输入边均为complete的节点的状态设置为ready。

24.根据权利要求18所述的装置，其特征在于，执行模块在确定有向计算图的全部节点的状态更新结束后，进行下一个计算周期的处理，包括：

线程池模块中的一个从线程模块遍历控制队列头部的有向计算图中的各个节点的状态，在确定该有向计算图中所有节点的状态为done的情况下，释放控制队列头部的有向计算图，并向处于等待状态的主线程模块发送通知(Notify)，以使主线程进行下一个计算周期的处理。

25.一种多模块调度装置，其特征在于，该多模块调度装置应用在一个从进程中，从进程中包括按照计算方向组合的多个多模块调度装置，该装置包括：

接收模块，用于在当前计算周期中，接收来自主进程的远程过程调用(RPC)的调用请求；对于具有多个输入数据的多模块调度装置，调用请求是主进程在确定多模块调度装置的多个输入数据都已就绪的情况下发出的；

执行模块，用于响应于调用请求执行处理；

反馈模块，用于在执行模块执行完处理后，计算模块向主进程反馈应答响应。

26.根据权利要求25所述的装置，其特征在于，接收模块接收到的调用请求中包括计算模块的标识、输入数据的存储地址和/或输出数据的存储地址；其中，输出数据的存储地址是从进程所对应的共享存储空间中的地址，该地址与计算模块相对应；或者，输出数据的存储地址是另一个从进程所应对的共享存储空间中的地址，该地址与计算模块相对应；输入数据的存储地址是从进程所对应的共享存储空间中的地址；

则，执行模块响应于调用请求执行处理，包括：

执行模块响应于调用请求，从输入数据的存储地址读取输入数据执行处理，并将输出数据写入到输出数据的存储地址中。

27.一种多模块调度装置，其特征在于，包括：一个处理器和至少一个存储器，至少一个存储器中存储有至少一条机器可执行指令，处理器执行至少一条机器可执行指令以实现：

读取预存的配置文件，配置文件中保存有一个有向计算图；其中，有向计算图与一个计算任务相对应，计算任务包括多个从进程，每个从进程包括按照计算方向组合的多个计算模块；有向计算图中包括多个节点，每个节点对应一个从进程中的一个计算模块，节点之间具有连接边，进入节点的连接边为输入边，离开节点的连接边为输出边；

在当前计算周期中，主进程初始化节点和连接边的状态；

根据有向计算图的计算方向以及节点的状态确定待调用节点，其中，待调用节点包括节点的多个输入边均为完成状态的节点；

向待调用节点对应的从进程中的计算模块发送远程过程调用(RPC)的调用请求以执行该计算模块；

在收到针对调用请求的应答响应后，更新该节点的状态和该节点的输出边的状态；

在确定有向计算图的全部节点的状态更新结束后，进行下一个计算周期的处理。

28.根据权利要求27所述的装置，其特征在于，处理器执行至少一条机器可执行指令以实现主线程和线程池，线程池中包括多个从线程；

节点的状态包括：未就绪(unready)、就绪(ready)、运行(run)和结束(done)；

连接边的状态包括：未完成(uncomplete)和完成(complete)。

29.根据权利要求28所述的装置，其特征在于，从进程中的计算模块包括并行计算模块和串行计算模块；则，

处理器执行至少一条机器可执行指令以实现主进程初始化节点和连接边的状态，包括：

主线程根据预定时间间隔判断控制队列中是否有空闲存储空间，在判断为否的情况下，主线程将自身的状态设置为等待(wait)，在判断为是的情况下，将一个有向计算图存入到一个控制队列的空闲存储空间中；

在控制队列中存储有多个有向计算图的情况下，按照队列方向，建立第i-1个存储空间中的有向计算图中与串行模块对应的节点至第i个存储空间中有向计算图的相同节点的输出边；2≤i≤n，n为控制队列中存储空间的数量，n为自然数；

初始化控制队列中新存入的有向计算图中节点和连接边的状态。

30.根据权利要求29所述的装置，其特征在于，处理器执行至少一条机器可执行指令以实现初始化控制队列中新存入的有向计算图中节点和连接边的状态，包括：

主线程判断新存入的有向计算图是否是控制队列中存储的第一个有向计算图；

在判断为是的情况下，将该有向计算图的起始节点设置为ready，将该有向计算图中的其它全部节点的状态设置为unready，将该有向计算图的全部连接边设置为uncomplete；

在判断为否的情况下，对于与该有向计算图相邻的上一个有向计算图的节点连接至该有向计算图的相同节点连接边，在相邻的上一个有向计算图的相同节点的状态为done的情况下，将该连接边的状态设置为complete，否则，将该连接边的状态设置为uncomplete；并且，将该有向计算图中节点的输入边均为complete的节点设置为ready，将其它全部节点的状态设置为unready，将该有向计算图的全部连接边设置为uncomplete。

31.根据权利要求28所述的装置，其特征在于，处理器执行至少一条机器可执行指令以实现根据有向计算图的计算方向以及节点的状态确定待调用节点，包括：

主线程在初始化控制队列中新存入的有向计算图中节点和连接边的状态后，根据计算方向遍历控制队列中各有向计算图中的各个节点的状态，将状态为ready的节点确定为待调用节点，其中，状态为ready的节点包括节点的多个输入边均为complete状态的节点；将待调用节点的状态修改为run，并将待调用节点推送到计算队列中，并且主线程进入等待状态；或者，

在计算过程中，线程池中的一个从线程根据计算方向遍历控制队列中各有向计算图中的各个节点的状态，将状态为ready的节点确定为待调用的节点，其中，状态为ready的节点包括节点的多个输入边均为complete状态的节点；将待调用节点的状态修改为run，并将待调用节点推送到计算队列中。

32.根据权利要求31所述的装置，其特征在于，处理器执行至少一条机器可执行指令以实现向待调用的节点对应的从进程中的计算模块发送RPC的调用请求以执行该计算模块，包括：

线程池中的一个从线程从计算队列中取出一个节点，向该节点对应的从进程中的计算模块发送RPC的调用请求。

33.根据权利要求32所述的装置，其特征在于，处理器执行至少一条机器可执行指令还实现：

根据预存的配置文件，线程池中的一个从线程确定从计算队列中取出的节点所对应的计算模块的标识、以及计算模块的输入数据的存储地址和/或输出数据的存储地址，将该计算模块的标识、输入数据的存储地址和/或输出数据的存储地址携带在调用请求中；

其中，计算模块的输出数据的存储地址是计算模块所在的从进程所对应的共享存储空间中的地址，该地址与计算模块相对应；或者，输出数据的存储地址是另一个从进程所应对的共享存储空间中的地址，该地址与计算模块相对应；

计算模块的输入数据的存储地址是计算模块所在的从进程所对应的共享存储空间中的地址。

34.根据权利要求28所述的装置，其特征在于，处理器执行至少一条机器可执行指令以实现：在收到针对调用请求的应答响应后，更新该节点的状态和该节点的输出边的状态，包括：

线程池中的一个从线程在收到针对一个节点所发出的调用请求的应答响应后，将该节点的状态设置为done，将该节点的输出边的状态修改为complete，并且将所有输入边均为complete的节点的状态设置为ready。

35.根据权利要求28所述的装置，其特征在于，处理器执行至少一条机器可执行指令以实现：在确定有向计算图的全部节点的状态更新结束后，进行下一个计算周期的处理，包括：

线程池中的一个从线程遍历控制队列头部的有向计算图中的各个节点的状态，在确定该有向计算图中所有节点的状态为done的情况下，释放控制队列头部的存储空间，并向处于等待状态的主线程发送通知(Notify)，以使主线程进行下一个计算周期的处理。

36.一种多模块调度装置，其特征在于，包括一个处理器和至少一个存储器，至少一个存储器中存储有至少一条机器可执行指令，处理器执行至少一条机器可执行指令以实现：

在当前计算周期中，收来自主进程的远程过程调用(RPC)的调用请求；对于具有多个输入数据的多模块调度装置，调用请求是主进程在确定多模块调度装置的多个输入数据都已就绪的情况下发出的；

响应于调用请求执行处理；

在处理执行完成后向主进程反馈应答响应。

37.根据权利要求36所述的装置，其特征在于，处理器执行至少一条机器可执行指令还实现：接收到的调用请求中包括计算模块的标识、输入数据的存储地址和/或输出数据的存储地址；其中，输出数据的存储地址是从进程所对应的共享存储空间中的地址，该地址与计算模块相对应；或者，输出数据的存储地址是另一个从进程所应对的共享存储空间中的地址，该地址与计算模块相对应；输入数据的存储地址是从进程所对应的共享存储空间中的地址；

则，处理器执行至少一条机器可执行指令以实现：响应于调用请求执行处理，包括：

响应于调用请求，从输入数据的存储地址读取输入数据执行处理，并将输出数据写入到输出数据的存储地址中。

38.一种多模块调度系统，其特征在于，包括：主进程和多个从进程；其中，每个从进程包括按照计算方向组合的多个计算模块；

主进程用于读取预存的配置文件，配置文件中保存有一个有向计算图；其中，有向计算图与一个计算任务相对应，计算任务包括多个从进程，每个从进程包括按照计算方向组合的多个计算模块；有向计算图中包括多个节点，每个节点对应一个从进程中的一个计算模块，节点之间具有连接边，进入节点的连接边为输入边，离开节点的连接边为输出边；在当前计算周期中，主进程初始化节点和连接边的状态；根据有向计算图的计算方向以及节点的状态确定待调用节点，其中，待调用节点包括节点的多个输入边均为完成状态的节点；向待调用节点对应的从进程中的计算模块发送远程过程调用(RPC)的调用请求以执行该计算模块；在收到针对调用请求的应答响应后，更新该节点的状态和该节点的输出边的状态；在确定有向计算图的全部节点的状态更新结束后，进行下一个计算周期的处理；

从进程中的一个计算模块接收来自主进程的RPC的调用请求；该计算模块响应于调用请求执行处理；在处理执行完成后，计算模块向主进程反馈应答响应。