CN105573717A - 一种面向多核处理器的程序划分方法及装置 - Google Patents

Abstract

本发明实施例提供一种面向多核处理器的程序划分方法及装置，涉及计算机技术领域，能够将整个程序划分为多个程序模块，且无需依赖于操作系统。该方法包括：从源程序的数据结构中的入口节点开始，依次标记该源程序的数据结构中的N个节点的层级，若该N个节点中层级为M的第一节点的计算量小于预设的第一计算量阈值，则为第一节点确定一个目标节点，将第一节点和第一节点的目标节点合并为第二节点，第二节点的层级与第一节点的目标节点的层级相同，将M加1，重复执行上述节点的合并过程，直至该源程序的数据结构中的所有节点合并结束。该方法用于将源程序划分为多个程序模块映射到CMP中执行。

Description

一种面向多核处理器的程序划分方法及装置

技术领域

本发明涉及计算机技术领域，尤其涉及一种面向多核处理器的程序划分方法及装置。

背景技术

随着计算机技术的不断发展，多核处理器(英文：chipmulti-processor，缩写：CMP)的应用越来越广泛。CMP在执行程序时，为了实现CMP的每个核并行执行以提高CMP的执行效率，可以对部分程序进行划分，并将划分后的各个程序模块分别映射到CMP的每个核中执行。

现有技术中，实现CMP的每个核并行执行的主要方式为依赖于主从线程模式的操作系统实现的OpenMP(英文：OpenMultipleProcessing，中文：开放多重处理)并行方式，其对程序进行划分、对划分后的程序模块进行调度，以及将调度后的程序模块映射到CMP的每个核中执行。其中，对程序进行划分主要指采用主从线程的fork-join(分叉-合并)模式对for循环进行划分。具体实现为在程序的头文件中增加OpenMP的库文件“omp.h”，并在for循环的第一行语句的前一行增加制导语句“#pragmaompparallelfor”，该制导语句的作用为需要对该for循环进行划分。编译器在编译程序的过程中，在程序开始的部分，编译器采用主线程单线程的方式执行，当编译器执行到制导语句时，编译器调用OpenMP的库文件对该for循环进行划分，即将该for循环划分为多个线程并行执行，当并行执行结束后，多个线程进行同步，并继续采用主线程单线程的方式往下执行，直到执行到下一个for循环。上述过程重复进行，直到程序执行结束。

然而，上述OpenMP并行方式只能对程序中的for循环进行划分，对于程序中常见的程序模块之间的流水线并行模式和函数模块之间的并行模式等，OpenMP并行方式并不能适用；同时OpenMP并行方式的实现需依赖于主从线程模式的操作系统，对于嵌入式系统等非主从线程模式的操作系统，OpenMP并行方式也无法适用，从而限制了CMP的并行处理性能。

发明内容

本发明的实施例提供一种面向多核处理器的程序划分方法及装置，能够将整个程序划分为多个程序模块，且无需依赖于操作系统，从而当划分后的多个程序模块映射到CMP执行时，可以更好地发挥CMP的并行处理性能。

为达到上述目的，本发明的实施例采用如下技术方案：

第一方面，本发明提供一种面向多核处理器的程序划分方法，包括：

从源程序的数据结构中的入口节点开始，依次标记所述源程序的数据结构中的N个节点的层级，所述入口节点的层级为1，所述入口节点为上依赖节点数量为0的节点，N≥1，N为整数；

由M＝1开始循环执行S1-S4，直至循环结束，M≤N，M为整数；

S1：若所述N个节点中层级为M的第一节点的计算量小于预设的第一计算量阈值，则根据所述第一节点的下依赖节点数量，从所述第一节点的依赖节点中确定备选节点集，所述备选节点集中的每个备选节点的计算量与所述第一节点的计算量之和均小于等于预设的第二计算量阈值；

S2：根据预设规则，从所述备选节点集中确定一个备选节点作为所述第一节点的目标节点；

S3：将所述第一节点和所述第一节点的目标节点合并为第二节点，所述第二节点的层级与所述第一节点的目标节点的层级相同；

S4：将M加1。

在第一方面的第一种可能的实现方式中，所述S1中根据所述第一节点的下依赖节点数量，从所述第一节点的依赖节点中确定备选节点集，包括：

若所述第一节点的下依赖节点数量大于等于1，则从所述第一节点的下依赖节点中确定备选节点集。

结合前述的第一方面或第一方面的第一种可能的实现方式，在第二种可能的实现方式中，所述S1中根据所述第一节点的下依赖节点数量，从所述第一节点的依赖节点中确定备选节点集，包括：

若所述第一节点的下依赖节点数量为0，则从所述第一节点的上依赖节点中确定备选节点集。

结合前述的第一方面或第一方面的第一种可能的实现方式至第二种可能的实现方式中的任一种实现方式，在第三种可能的实现方式中，所述第一节点的下依赖节点数量为1，所述备选节点集中包括一个备选节点，

其中，所述S2中根据预设规则，从所述备选节点集中确定一个备选节点作为所述第一节点的目标节点，包括：

将所述一个备选节点作为所述第一节点的目标节点。

结合前述的第一方面或第一方面的第一种可能的实现方式至第三种可能的实现方式中的任一种实现方式，在第四种可能的实现方式中，所述第一节点的下依赖节点数量大于1，所述预设规则为备选节点的层级和备选节点的上依赖节点数量，

其中，所述S2中根据预设规则，从所述备选节点集中确定一个备选节点作为所述第一节点的目标节点，包括：

根据所述备选节点的层级，从所述备选节点集中确定层级最小的至少一个备选节点；

根据所述备选节点的上依赖节点数量，从所述层级最小的至少一个备选节点中确定上依赖节点数量最大的所述一个备选节点，作为所述第一节点的目标节点。

结合前述的第一方面或第一方面的第一种可能的实现方式至第四种可能的实现方式中的任一种实现方式，在第五种可能的实现方式中，所述第一节点的下依赖节点数量为0，所述预设规则为备选节点的上依赖节点数量，

其中，所述S2中根据预设规则，从所述备选节点集中确定一个备选节点作为所述第一节点的目标节点，包括：

根据所述备选节点的上依赖节点数量，从所述备选节点集中确定上依赖节点数量最大的所述一个备选节点作为所述第一节点的目标节点。

结合前述的第一方面或第一方面的第一种可能的实现方式至第五种可能的实现方式中的任一种实现方式，在第六种可能的实现方式中，所述第一节点的下依赖节点数量为0，所述预设规则为备选节点的计算量和备选节点的上依赖节点数量，

其中，所述S2中根据预设规则，从所述备选节点集中确定一个备选节点作为所述第一节点的目标节点，包括：

根据所述备选节点的计算量，从所述备选节点集中确定计算量最小的至少一个备选节点；

根据所述备选节点的上依赖节点数量，从所述计算量最小的至少一个备选节点中确定上依赖节点数量最大的所述一个备选节点，作为所述第一节点的目标节点。

结合前述的第一方面或第一方面的第一种可能的实现方式至第六种可能的实现方式中的任一种实现方式，在第七种可能的实现方式中，所述从源程序的数据结构中的入口节点开始，依次标记所述源程序的数据结构中的N个节点的层级之前，所述方法还包括：

采用静态单赋值SSA技术，生成所述源程序的数据结构，所述源程序的数据结构包括所述N个节点的数据结构，所述N个节点中的每个节点的数据结构至少包括所述节点的下依赖节点、所述节点的下依赖节点数量、所述节点的上依赖节点、所述节点的计算量，以及所述节点的生命期。

结合第一方面的第七种可能的实现方式，在第八种可能的实现方式中，所述S3中将所述第一节点和所述第一节点的目标节点合并为第二节点，包括：

根据所述第一节点的数据结构和所述第一节点的目标节点的数据结构，确定所述第二节点的数据结构，所述第二节点的数据结构中包括所述第二节点的层级。

结合前述的第一方面或第一方面的第一种可能的实现方式至第八种可能的实现方式中的任一种实现方式，在第九种可能的实现方式中，所述方法还包括：

S5：若所述第一节点的计算量大于等于所述第一计算量阈值，且所述第一节点的下依赖节点数量大于等于1，则执行S4。

结合前述的第一方面或第一方面的第一种可能的实现方式至第九种可能的实现方式中的任一种实现方式，在第十种可能的实现方式中，所述方法还包括：

S6：若所述第一节点的计算量大于等于所述第一计算量阈值，且所述第一节点的下依赖节点数量为0，则结束循环。

结合前述的第一方面或第一方面的第一种可能的实现方式至第十种可能的实现方式中的任一种实现方式，在第十一种可能的实现方式中，所述方法还包括：

将下依赖节点数量和上依赖节点数量均为0的所有节点合并为所述第二节点。

结合第一方面的第七种可能的实现方式，在第十二种可能的实现方式中，所述采用SSA技术，生成所述源程序的数据结构之后，所述方法还包括：

为所述N个节点中的每个节点分别分配存储地址。

结合第一方面的第十二种可能的实现方式，在第十三种可能的实现方式中，在循环结束后，所述N个节点合并为K个第二节点，所述K个第二节点表征K个线程，1≤K＜N，K为整数，所述方法还包括：

若第一线程中的第一子节点的生命周期为0，且所述第一子节点的下依赖节点数量为1，则将所述第一子节点的存储地址分配给第二子节点，所述第二子节点为所述第一线程中的所述第一子节点的下依赖节点，所述第一线程为所述K个线程中的一个。

第二方面，本发明提供一种面向多核处理器的程序划分装置，包括：

标记单元，用于从源程序的数据结构中的入口节点开始，依次标记所述源程序的数据结构中的N个节点的层级，所述入口节点的层级为1，所述入口节点为上依赖节点数量为0的节点，N≥1，N为整数；

执行单元，用于由M＝1开始循环执行S1-S4，直至循环结束，M≤N，M为整数；

S1：若所述N个节点中所述标记单元标记的层级为M的第一节点的计算量小于预设的第一计算量阈值，则根据所述第一节点的下依赖节点数量，从所述第一节点的依赖节点中确定备选节点集，所述备选节点集中的每个备选节点的计算量与所述第一节点的计算量之和均小于等于预设的第二计算量阈值；

S2：根据预设规则，从所述备选节点集中确定一个备选节点作为所述第一节点的目标节点；

S3：将所述第一节点和所述第一节点的目标节点合并为第二节点，所述第二节点的层级与所述第一节点的目标节点的层级相同；

S4：将M加1。

在第二方面的第一种可能的实现方式中，

所述执行单元，具体用于若所述第一节点的下依赖节点数量大于等于1，则从所述第一节点的下依赖节点中确定备选节点集。

结合前述的第二方面或第二方面的第一种可能的实现方式，在第二种可能的实现方式中，

所述执行单元，具体用于若所述第一节点的下依赖节点数量为0，则从所述第一节点的上依赖节点中确定备选节点集。

结合前述的第二方面或第二方面的第一种可能的实现方式至第二种可能的实现方式中的任一种实现方式，在第三种可能的实现方式中，所述第一节点的下依赖节点数量为1，所述备选节点集中包括一个备选节点，

所述执行单元，具体用于将所述一个备选节点作为所述第一节点的目标节点。

结合前述的第二方面或第二方面的第一种可能的实现方式至第三种可能的实现方式中的任一种实现方式，在第四种可能的实现方式中，所述第一节点的下依赖节点数量大于1，所述预设规则为备选节点的层级和备选节点的上依赖节点数量，

所述执行单元，具体用于根据所述备选节点的层级，从所述备选节点集中确定层级最小的至少一个备选节点，并根据所述备选节点的上依赖节点数量，从所述层级最小的至少一个备选节点中确定上依赖节点数量最大的所述一个备选节点，作为所述第一节点的目标节点。

结合前述的第二方面或第二方面的第一种可能的实现方式至第四种可能的实现方式中的任一种实现方式，在第五种可能的实现方式中，所述第一节点的下依赖节点数量为0，所述预设规则为备选节点的上依赖节点数量，

所述执行单元，具体用于根据所述备选节点的上依赖节点数量，从所述备选节点集中确定上依赖节点数量最大的所述一个备选节点作为所述第一节点的目标节点。

结合前述的第二方面或第二方面的第一种可能的实现方式至第五种可能的实现方式中的任一种实现方式，在第六种可能的实现方式中，所述第一节点的下依赖节点数量为0，所述预设规则为备选节点的计算量和备选节点的上依赖节点数量，

所述执行单元，具体用于根据所述备选节点的计算量，从所述备选节点集中确定计算量最小的至少一个备选节点，并根据所述备选节点的上依赖节点数量，从所述计算量最小的至少一个备选节点中确定上依赖节点数量最大的所述一个备选节点，作为所述第一节点的目标节点。

结合前述的第二方面或第二方面的第一种可能的实现方式至第六种可能的实现方式中的任一种实现方式，在第七种可能的实现方式中，所述程序划分装置还包括：

生成单元，用于在所述标记单元从源程序的数据结构中的入口节点开始，依次标记所述源程序的数据结构中的N个节点的层级之前，采用静态单赋值SSA技术，生成所述源程序的数据结构，所述源程序的数据结构包括所述N个节点的数据结构，所述N个节点中的每个节点的数据结构至少包括所述节点的下依赖节点、所述节点的下依赖节点数量、所述节点的上依赖节点、所述节点的计算量，以及所述节点的生命期。

结合第二方面的第七种可能的实现方式，在第八种可能的实现方式中，

所述执行单元，具体用于根据所述第一节点的数据结构和所述第一节点的目标节点的数据结构，确定所述第二节点的数据结构，所述第二节点的数据结构中包括所述第二节点的层级。

结合前述的第二方面或第二方面的第一种可能的实现方式至第八种可能的实现方式中的任一种实现方式，在第九种可能的实现方式中，

所述执行单元，还用于执行S5，

S5：若所述第一节点的计算量大于等于所述第一计算量阈值，且所述第一节点的下依赖节点数量大于等于1，则执行S4。

结合前述的第二方面或第二方面的第一种可能的实现方式至第九种可能的实现方式中的任一种实现方式，在第十种可能的实现方式中，

所述执行单元，还用于执行S6，

S6：若所述第一节点的计算量大于等于所述第一计算量阈值，且所述第一节点的下依赖节点数量为0，则结束循环。

结合前述的第二方面或第二方面的第一种可能的实现方式至第十种可能的实现方式中的任一种实现方式，在第十一种可能的实现方式中，

所述执行单元，还用于将下依赖节点数量和上依赖节点数量均为0的所有节点合并为所述第二节点。

结合第二方面的第七种可能的实现方式，在第十二种可能的实现方式中，所述程序划分装置还包括：

分配单元，用于在所述生成单元采用SSA技术，生成所述源程序的数据结构之后，为所述N个节点中的每个节点分别分配存储地址。

结合第二方面的第十二种可能的实现方式，在第十三种可能的实现方式中，在所述执行单元执行循环结束后，所述N个节点合并为K个第二节点，所述K个第二节点表征K个线程，1≤K＜N，K为整数，

所述分配单元，还用于若第一线程中的第一子节点的生命周期为0，且所述第一子节点的下依赖节点数量为1，则将所述第一子节点的存储地址分配给第二子节点，所述第二子节点为所述第一线程中的所述第一子节点的下依赖节点，所述第一线程为所述K个线程中的一个。

本发明提供一种面向多核处理器的程序划分方法及装置，通过从源程序的数据结构中的入口节点开始，依次标记源程序的数据结构中的N个节点的层级，当该N个节点中层级为M的第一节点的计算量小于预设的第一计算量阈值时，根据第一节点的下依赖节点数量，从第一节点的依赖节点中确定备选节点集，该备选节点集中的每个备选节点的计算量与第一节点的计算量之和均小于等于第二计算量阈值，再根据预设规则，从该备选节点集中确定一个备选节点作为第一节点的目标节点，以及将第一节点和第一节点的目标节点合并为第二节点，第二节点的层级与第一节点的目标节点的层级相同，将M加1后，重复执行上述节点的合并过程，直至该源程序的数据结构中的所有节点合并结束。由于源程序的数据结构中的N个节点表示源程序的N个语句，因此本发明通过采用上述方法将源程序的数据结构中的N个节点合并为多个第二节点，可以将源程序划分为多个程序模块，其中，一个第二节点表示一个程序模块，一个程序模块包括至少一个语句，从而能够将整个程序划分为多个程序模块。且由于本发明的面向多核处理器的程序划分方法可以应用于多种操作系统，并不限于主从线程模式的操作系统，因此本发明在对程序进行划分时无需依赖于操作系统。进而当划分后的多个程序模块映射到CMP执行时，可以更好地发挥CMP的并行处理性能。

附图说明

图1为本发明实施例提供的一种面向多核处理器的程序划分方法的流程图一；

图2为本发明实施例提供的源程序的数据结构的示意图一；

图3为本发明实施例提供的源程序的数据结构的示意图二；

图4为本发明实施例提供的一种面向多核处理器的程序划分方法的流程图二；

图5为本发明实施例提供的一种面向多核处理器的程序划分方法的流程图三；

图6为本发明实施例提供的满足仿射访问条件的循环的数据结构的示意图；

图7为本发明实施例提供的程序划分装置的结构示意图一；

图8为本发明实施例提供的程序划分装置的结构示意图二；

图9为本发明实施例提供的程序划分装置的结构示意图三；

图10为本发明实施例提供的程序划分装置的结构示意图四。

具体实施方式

下面将结合本发明实施例中的附图，对本发明实施例中的技术方案进行清楚、完整地描述，显然，所描述的实施例仅仅是本发明一部分实施例，而不是全部的实施例。

本发明实施例提供的一种面向多核处理器的程序划分方法，可以通过能够实现本发明实施例对程序进行划分的独立的软件模块实现，也可以将能够实现本发明实施例对程序进行划分的软件模块集成在编译器中，通过编译器实现。即本发明实施例提供的面向多核处理器的程序划分方法的执行主体可以为上述的编译器，也可以为上述的独立的软件模块。下面实施例以编译器为例，对本发明实施例提供的面向多核处理器的程序划分方法进行示例性的说明。

实施例一

本发明实施例提供一种面向多核处理器的程序划分方法，如图1所示，该方法可以包括：

S101、编译器从源程序的数据结构中的入口节点开始，依次标记该源程序的数据结构中的N个节点的层级，该入口节点的层级为1，该入口节点为上依赖节点数量为0的节点，N≥1，N为整数。

其中，源程序的数据结构中的入口节点可以有一个，也可以有多个，即层级为1的节点可以有一个，也可以有多个。

其中，编译器可以通过对该源程序采用静态单赋值(英文：StaticSingleAssignment缩写：SSA)技术，将该源程序中的所有语句，转换成N个节点，并生成该N个节点的数据结构，其中，该N个节点的数据结构构成该源程序的数据结构。

示例性的，例如，源程序为：

1sum＝0；

2i＝1；

3b＝i*i；

4sum+＝b；

5i+＝1；

6b＝i*i；

7sum+＝b；

8i＝i-2；

该编译器通过SSA技术，将该源程序中的8个语句转换为8个节点，分别为：语句“sum＝0；”转换为节点sum<0>；语句“i＝1；”转换为节点i<0>；语句“b＝i*i；”转换为节点b<0>；语句“sum+＝b；”转换为节点sum<1>；语句“i+＝1；”转换为节点i<1>；语句“b＝i*i；”转换为节点b<1>；语句“sum+＝b；”转换为节点sum<2>；语句“i＝i-2；”转换为节点i<2>。编译器可根据源程序中各个语句的变量之间的关系，生成每个节点的数据结构，并由该8个节点的数据结构构成该源程序的数据结构，其中，该源程序的数据结构的示意图如图2(a)所示。

进一步地，该N个节点中每个节点的数据结构至少包括该节点的下依赖节点、该节点的下依赖节点数量、该节点的上依赖节点、该节点的上依赖节点数量、以及该节点的计算量。

为了更好的说明节点的上依赖节点和节点的下依赖节点的含义，下面以该源程序的数据结构中的节点i<0>和节点b<0>为例，对节点的上依赖节点和节点的下依赖节点进行示例性的说明。

如该源程序所示，由语句“b＝i*i；”可知，变量b的赋值是通过变量i乘以i所得的，即可以理解为变量b的赋值依赖于变量i的赋值。例如，当i＝1时，b＝1*1＝1；当i＝2时，b＝2*2＝4。将语句“b＝i*i；”转换成节点b<0>，将语句“i＝1；”转换成节点i<0>后，由于变量b的赋值依赖于变量i的赋值，因此节点b<0>与节点i<0>之间存在依赖关系，即节点b<0>是节点i<0>的下依赖节点，节点i<0>是节点b<0>的上依赖节点。

为了准确地表示每个节点在源程序中的属性，每个节点的数据结构还可以包括除上述描述的属性之外的其他属性。具体的，N个节点中的每个节点的数据结构可以表示为如下的代码：

Typedefstructnode{//node为每个节点

intname；//node对应变量的变量名

intname_index；//node对应变量名在所处函数变量名中的标号

intnum；//node在对应变量中所有node中的标号

intvalue；//node的值

intnodetype；//node的类型，如果为constidentifier，则值为0；如果为const产生的IFnode，则值为1；如果为输入变量，则值为2；如果为输入变量派生的变量，则值为3；如果为函数node，则值为4；如果为输入变量产生的IFnode，则值为5；如果为输出变量，则值为6；

charreadtext[200]；//node的可读代码；

charexetext[200]；//node的可执行代码；

intcal；//node的计算量；

intline；//node对应语句在输入程序中的行号

structnode*up_depend[20]；//node的上依赖node

structnode*down_depend[20]；//node的下依赖node

intup_num；//node上依赖node的数量

intdown_num；//node下依赖node的数量

intlevel；//node的等级层次，表征其执行顺序

intthread；//node所在thread标号

intcount；//node变量名的生命周期

intrename；//node的重命名

}node；

本发明实施例中，若该节点的上依赖节点数量为0，则该节点为该源程序的数据结构中的入口节点，该编译器从该入口节点开始，依次标记该N个节点的层级，其中，该入口节点的层级为1。

本发明实施例中，由于需从层级为1的节点开始依次找到可以与上一层级的节点合并的节点，因此，入口节点的层级可以标记为1，且该入口节点可认为是开始合并的节点。当然，本发明实施例可以不限制节点的层级的具体标记数值，即本发明实施例也可以将入口节点的层级标记为其他数值，相应的，从入口节点开始依次找可以与上一层级的节点合并的节点时，也需相应的根据标记的节点的层级进行适应性的调整。

示例性的，上述源程序的数据结构中包括8个节点的数据结构，其中，节点sum<0>和节点i<0>没有上依赖节点，因此节点sum<0>和节点i<0>为源程序的数据结构的两个入口节点。该编译器从该两个入口节点开始，依次标记该8个节点的层级，分别为将节点sum<0>的层级和节点i<0>的层级标记为1，将节点b<0>的层级和节点i<1>的层级标记为2，将节点sum<1>的层级，节点b<1>的层级和节点i<2>的层级标记为3，将节点sum<2>的层级标记为4。

S102、由M＝1开始循环执行S103-S106，直至循环结束，M≤N，M为整数。

S103、若该N个节点中层级为M的第一节点的计算量小于预设的第一计算量阈值，则该编译器根据该第一节点的下依赖节点数量，从该第一节点的依赖节点中确定备选节点集，该备选节点集中的每个备选节点的计算量与该第一节点的计算量之和均小于等于预设的第二计算量阈值。

具体的，根据第一节点的下依赖节点数量，从该第一节点的依赖节点中确定备选节点集的方法可以包括：

(1)若该第一节点的下依赖节点数量大于等于1，则该编译器可从该第一节点的下依赖节点中确定备选节点集。

(2)若该第一节点的下依赖节点数量等于0，则该编译器可从该第一节点的上依赖节点中确定备选节点集。

S104、该编译器根据预设规则，从该备选节点集中确定一个备选节点作为该第一节点的目标节点。

其中，第一节点的目标节点可以理解为能够与第一节点合并为一个节点的节点。

具体的，该编译器根据预设规则，从备选节点集中确定一个备选节点作为该第一节点的目标节点的具体实现方式，可以为下述的一种：

(1)当该第一节点的下依赖节点数量为1时，备选节点集中包括一个备选节点(第一节点的下依赖节点)，则该编译器可将该一个备选节点为该第一节点的目标节点。

(2)当该第一节点的下依赖节点数量大于1时，备选节点集中包括多个备选节点(第一节点的下依赖节点)，预设规则可以为该备选节点集中的备选节点的层级和备选节点的上依赖节点数量。具体的，该编译器可根据备选节点的层级，首先从该备选节点集中确定层级最小的至少一个备选节点，再根据备选节点的上依赖节点数量，从层级最小的至少一个备选节点中确定上依赖节点数量最大的一个备选节点作为该第一节点的目标节点。

(3)当该第一节点的下依赖节点数量为0时，备选节点集中包括多个备选节点(第一节点的上依赖节点)，预设规则可以为该备选节点集中的备选节点的上依赖节点数量。具体的，该编译器可根据备选节点的上依赖节点数量，从该备选节点集中确定上依赖节点数量最大的一个备选节点作为该第一节点的目标节点。

(4)当该第一节点的下依赖节点数量为0时，备选节点集中包括多个备选节点(第一节点的上依赖节点)，预设规则可以为该备选节点集中的备选节点的计算量和备选节点的上依赖节点数量。具体的，该编译器可根据备选节点的计算量，从该备选节点集中确定计算量最小的至少一个备选节点，再根据备选节点的上依赖节点数量，从计算量最小的至少一个备选节点中确定上依赖节点数量最大的一个备选节点作为该第一节点的目标节点。

S105、该编译器将该第一节点和该第一节点的目标节点合并为第二节点，该第二节点的层级与该第一节点的目标节点的层级相同。

具体的，上述该编译器将第一节点和该第一节点的目标节点合并为第二节点的方法可以为：该编译器根据该第一节点的数据结构和该第一节点的目标节点的数据结构，确定该第二节点的数据结构。例如，在该第二节点的数据结构中，该第二节点的下依赖节点数量为该第一节点的下依赖节点中除该第一节点的目标节点之外的下依赖节点数量，和该第一节点的目标节点的下依赖节点数量之和，该第二节点的上依赖节点数量为该第一节点的上依赖节点数量，和该第一节点的目标节点的上依赖节点中除该第一节点之外的上依赖节点数量之和，该第二节点的下依赖节点为该第一节点的目标节点的下依赖节点，和该第一节点的下依赖节点中除该第一节点的目标节点之外的下依赖节点，该第二节点的层级与该第一节点的目标节点的层级相同。

示例性的，如图3(a)所示，假设第一节点为节点{3,4,5}，第一节点{3,4,5}有2个上依赖节点，分别为节点1和节点2，第一节点{3,4,5}的目标节点为节点8，目标节点8有2个上依赖节点，分别为第一节点{3,4,5}和节点6。当该编译器将第一节点{3,4,5}和目标节点8合并成第二节点{3,4,5,8}后，如图3(b)所示，第二节点{3,4,5,8}的上依赖节点数量为第一节点{3,4,5}的上依赖节点数量，和目标节点8上依赖节点中除第一节点{3,4,5}之外的上依赖节点数量之和，即第二节点{3,4,5,8}有3个上依赖节点，分别为节点1，节点2，以及节点6。

同理，如图3(c)所示，第一节点{3,4,5}有2个下依赖节点，分别为节点7和目标节点8，目标节点8具有1个下依赖节点9，当该编译器将第一节点{3,4,5}和目标节点8合并形成第二节点{3,4,5,8}后，如图3(d)所示，第二节点{3,4,5,8}的下依赖节点数量为第一节点{3,4,5}的下依赖节点中除目标节点8之外的下依赖节点数量，和目标节点8的下依赖节点数量之和，即第二节点{3,4,5,8}有2个下依赖节点，分别节点7和节点9。

S106、该编译器将M加1。

具体的，该编译器由层级为1的第一节点开始进行合并，当该编译器合并到层级为M的第一节点时，若层级为M的第一节点的计算量大于等于上述的第一计算量阈值，且该第一节点的下依赖节点数量为0，则上述循环结束；或者，若层级为M的第一节点的计算量小于上述的第一计算量阈值，且该第一节点的上依赖节点数量和下依赖节点数量都为0，则上述循环结束。

进一步地，为了更好的说明本发明实施例提供的面向多核处理器的程序划分方法，下面以对上述列出的源程序进行划分为例，进行示例性的说明。

当该编译器标记完该源程序的数据结构中的所有节点的层级后，从层级为1的节点开始进行合并，即将层级为1的节点作为第一节点，为该第一节点选择一个目标节点，并将该第一节点与该目标节点进行合并，形成第二节点。在该源程序的数据结构中，层级为1的节点有两个，分别为：节点sum<0>和节点i<0>。当该编译器需要选择节点sum<0>进行合并，或者选择节点i<0>进行合并时，编译器可以根据节点sum<0>的数据结构中节点sum<0>的标号和节点i<0>的数据结构中节点i<0>的标号的大小进行选择，在本实施例中，假设节点sum<0>的标号为1，节点i<0>的标号为2，该编译器可选择节点sum<0>作为首先进行合并的第一节点。

可选的，若层级为1的多个节点的下依赖节点都不相同，例如本实施例中，节点sum<0>的下依赖节点为节点sum<1>，节点i<0>的下依赖节点为节点b<0>和节点i<1>，则当该编译器需要选择节点sum<0>进行合并，或者选择节点i<0>进行合并时，由于层级相同的节点之间不存在依赖关系，因此层级相同的节点在分别与和其具有依赖关系的节点进行合并时，合并的先后顺序对源程序的划分结果没有影响，因此该编译器可在节点sum<0>和节点i<0>中随机选择一个节点作为首先进行合并的第一节点。

假设该编译器首先从层级为1的第一节点sum<0>开始进行合并。首先，该编译器判断第一节点sum<0>的计算量是否小于预设的第一计算量阈值，若第一节点sum<0>的计算量小于预设的第一计算量阈值，则为第一节点sum<0>选择一个目标节点，并将第一节点sum<0>和该目标节点合并。由于第一节点sum<0>只有一个层级为2的下依赖节点sum<1>，且该下依赖节点sum<1>的计算量与第一节点sum<0>的计算量之和小于等于预设的第二计算量阈值，因此，该编译器选择该下依赖节点sum<1>作为第一节点sum<0>的目标节点(可称为目标节点sum<1>)，并将目标节点sum<1>和第一节点sum<0>合并为一个第二节点。目标节点sum<1>和第一节点sum<0>合并后形成第二节点{sum<0>，sum<1>},且第二节点{sum<0>，sum<1>}的数据结构由目标节点sum<1>的数据结构和第一节点sum<0>的数据结构确定得到。例如，第二节点{sum<0>，sum<1>}的数据结构中，第二节点{sum<0>，sum<1>}的计算量为目标节点sum<1>的计算量和第一节点sum<0>计算量之和，第二节点{sum<0>，sum<1>}的下依赖节点数量为目标节点sum<1>的下依赖节点数量，和第一节点sum<0>的下依赖节点中除目标节点sum<1>之外的下依赖节点数量之和，第二节点{sum<0>，sum<1>}的下依赖节点为目标节点sum<1>的下依赖节点，和第一节点sum<0>的下依赖节点中除目标节点sum<1>之外的下依赖节点，第二节点{sum<0>，sum<1>}的层级为目标节点sum<1>的层级等。

然后，该编译器对源程序的数据结构中另一个入口节点i<0>，即层级为1的第一节点i<0>进行合并，若第一节点i<0>的计算量小于预设的第一计算量阈值，则为第一节点i<0>选择一个目标节点，并将第一节点i<0>和该目标节点合并。由于第一节点i<0>的下依赖节点有两个，分别为节点b<0>和节点i<1>，则首先需要要判断第一节点i<0>的计算量与节点b<0>计算量之和，以及第一节点i<0>的计算量与节点i<1>计算量之和是否都小于等于预设的第二计算量阈值，若第一节点i<0>的计算量与节点b<0>计算量之和，以及第一节点i<0>的计算量与节点i<1>的计算量之和都小于等于预设的第二计算量阈值，则节点b<0>和节点i<1>构成第一节点i<0>的备选节点集。该编译器需要从该备选节点集中选择一个备选节点作为第一节点i<0>的目标节点与第一节点i<0>合并。例如，该编译器可以从节点b<0>和节点i<1>中选择一个层级最小且上依赖节点数量最大的一个备选节点，作为第一节点i<0>的目标节点。由于节点b<0>和节点i<1>的层级相同都为2，且节点b<0>和节点i<1>的上依赖节点数量也相同，因此可以在节点b<0>和节点i<1>中随机选择一个备选节点作为第一节点i<0>的目标节点,并将第一节点i<0>与该目标节点进行合并。假设该编译器选择节点b<0>作为第一节点i<0>的目标节点(可称为目标节点b<0>)与第一节点i<0>合并，那么，目标节点b<0>与第一节点i<0>合并完成后，形成第二节点{b<0>，i<0>},且第二节点{b<0>，i<0>}的数据结构由目标节点b<0>的数据结构和第一节点i<0>的数据结构确定得到。具体的，第二节点{b<0>，i<0>}的数据结构确定的方法与上述第二节点{sum<0>，sum<1>}的数据结构的确定方法类似，此处不再赘述。

至此，层级为1的节点合并结束，层级为1的节点合并结束后源程序的数据结构的示意图如图2(b)所示，层级为1的节点合并结束后源程序的数据结构中有6个节点，分别为节点{sum<0>，sum<1>}，节点{b<0>，i<0>}，节点i<1>，节点b<1>，节点i<2>和节点sum<2>。

需要说明的是，由于第一节点i<0>与节点i<1>之间存在直接依赖关系，即节点i<1>是第一节点i<0>的下依赖节点，因此在对层级为1的节点合并结束后，第一节点i<0>与节点b<0>合并后形成的第二节点{b<0>，i<0>}与节点i<1>之间存在依赖关系，因为第二节点{b<0>，i<0>}与节点i<1>之间的依赖关系是由于层级为1的第一节点i<0>在进行合并时引入到层级为2的第二节点{b<0>，i<0>}中的，所以当该编译器对层级为2的第二节点{b<0>，i<0>}进行合并时，可以不考虑第二节点{b<0>，i<0>}与节点i<1>之间的依赖关系。

对层级为1的节点合并结束后，该编译器再开始对层级为2的节点进行合并。层级为1的节点合并结束后，层级为2的节点变为：节点{i<0>，b<0>}和节点i<1>。假设，节点{i<0>，b<0>}的计算量和节点i<1>的计算量都小于预设的第一计算量阈值，那么该编译器首先对层级为2的第一节点{i<0>，b<0>}进行合并，第一节点{i<0>，b<0>}只有一个层级为3的下依赖节点{sum<0>，sum<1>}，且第一节点{i<0>，b<0>}的计算量与该下依赖节点{sum<0>，sum<1>}的计算量之和小于等于预设的第二计算量阈值，因此该编译器将该下依赖节点{sum<0>，sum<1>}作为第一节点{i<0>，b<0>}的目标节点(可称为目标节点sum<0>，sum<1>})，并将第一节点{i<0>，b<0>}与目标节点{sum<0>，sum<1>}进行合并，形成第二节点{i<0>，b<0>，sum<0>，sum<1>}。然后再对层级为2的第一节点i<1>进行合并，由于第一节点i<1>的下依赖节点有两个，分别为节点b<1>和节点i<2>，且节点b<1>的计算量与节点i<1>的计算量之和，以及节点i<2>的计算量与节点i<1>的计算量之和都小于等于预设的第二计算量阈值，则节点b<1>和节点i<2>构成了第一节点i<1>的备选节点集。由于节点b<1>和节点i<2>的层级相同都为3，且节点b<1>和节点i<2>的上依赖节点数量也相同，因此该编译器可在节点b<1>和节点i<2>中随机选择一个备选节点作为第一节点i<1>目标节点，并将第一节点i<1>与该目标节点进行合并。假设该编译器选择节点b<1>作为第一节点i<1>的目标节点(可称为目标节点b<1>)与第一节点i<1>合并，那么目标节点b<1>)与第一节点i<1>合并完成后，形成第二节点{i<1>，b<1>},且第二节点{i<1>，b<1>}的数据结构由目标节点b<1>的数据结构和第一节点i<1>的数据结构确定得到。具体的，第二节点{i<1>，b<1>}的数据结构确定的方法与上述第二节点{sum<0>，sum<1>}的数据结构的确定方法类似，此处不再赘述。

至此，层级为2的节点合并结束，层级为2的节点合并结束后源程序的数据结构的示意图如图2(c)所示，层级为2的节点合并结束后源程序的数据结构中有4个节点，分别为节点{i<1>，b<1>}，节点{i<0>，b<0>，sum<0>，sum<1>}，节点sum<2>和节点i<2>。

对层级为2的节点合并结束后，该编译器再开始对层级为3的节点进行合并。层级为2的节点合并结束后，层级为3的节点变为：节点{i<0>，b<0>，sum<0>，sum<1>}、节点{i<1>，b<1>}和节点i<2>。该编译器首先分别判断节点{i<0>，b<0>，sum<0>，sum<1>}的计算量、节点{i<1>，b<1>}的计算量，以及节点i<2>的计算量是否小于预设的第一计算量阈值。假设节点{i<0>，b<0>，sum<0>，sum<1>}的计算量大于等于预设的第一计算量阈值，则该编译器不对节点{i<0>，b<0>，sum<0>，sum<1>}继续合并，且节点{i<1>，b<1>}的计算量和节点i<2>的计算量都小于预设的第一计算量阈值，因此该编译器继续对节点{i<1>，b<1>}和节点i<2>进行合并。首先对层级为3的第一节点{i<1>，b<1>}进行合并，由于第一节点{i<1>，b<1>}只有一个层级为4的下依赖节点sum<2>，因此当第一节点{i<1>，b<1>}的计算量和该下依赖节点sum<2>的计算量之和小于等于预设的第二计算量阈值时，该编译器将该下依赖节点sum<2>作为第一节点{i<1>，b<1>}的目标节点(可称为目标节点sum<2>)，并将目标节点sum<2>和第一节点{i<1>，b<1>}进行合并，形成第二节点{i<1>，b<1>，sum<2>},且第二节点{i<1>，b<1>，sum<2>}的数据结构由目标节点sum<2>的数据结构和第一节点{i<1>，b<1>}的数据结构确定得到。具体的，第二节点{i<1>，b<1>，sum<2>}的数据结构确定的方法与上述第二节点{sum<0>，sum<1>}的数据结构的确定方法类似，此处不再赘述。

至此，源程序的数据结构的示意图如图2(d)所示，源程序的数据结构中有3个节点，分别为节点{i<1>，b<1>，sum<2>}，节点{i<0>，b<0>，sum<0>，sum<1>}和节点i<2>。

然后，该编译器再对层级为3的第一节点i<2>进行合并，由于第一节点i<2>的下依赖节点数量为0，因此在第一节点i<2>的上依赖节点中，为第一节点i<2>选择一个目标节点进行合并。由于第一节点i<2>只有一个层级为2的上依赖节点{i<1>，b<1>，sum<2>}，因此，当第一节点i<2>的计算量和该上依赖节点{i<1>，b<1>，sum<2>}计算量之和小于等于预设的第二计算量阈值时，该编译器将节点{i<1>，b<1>，sum<2>}作为第一节点i<2>的目标节点(可称为目标节点{i<1>，b<1>，sum<2>})，并将目标节点{i<1>，b<1>，sum<2>}和第一节点i<2>进行合并，形成第二节点{i<1>，b<1>，sum<2>，i<2>},且第二节点{i<1>，b<1>，sum<2>，i<2>}的数据结构由目标节点{i<1>，b<1>，sum<2>}的数据结构和第一节点i<2>的数据结构确定得到。具体的，第二节点{i<1>，b<1>，sum<2>，i<2>}的数据结构确定的方法与上述第二节点{sum<0>，sum<1>}的数据结构的确定方法类似，此处不再赘述。

至此，层级为3的节点合并结束，层级为3的节点合并结束后源程序的数据结构的示意图如图2(e)所示，层级为3的节点合并结束后源程序的数据结构中有2个节点，分别为节点{i<1>，b<1>，sum<2>，i<2>}和节点{i<0>，b<0>，sum<0>，sum<1>}。

至此，源程序的数据结构中的所有节点合并为两个节点，这两个节点分别可以表示为：节点{i<0>，b<0>，sum<0>，sum<1>}和节点{i<1>，b<1>，sum<2>，i<2>}，即该编译器将该源程序划分为2个程序模块，这两个程序模块可以表示为：第一个程序模块为与节点{i<0>，b<0>，sum<0>，sum<1>}对应的程序模块“sum＝0；i＝1；b＝i*i；sum+＝b；”，第二个程序模块为与节点{i<1>，b<1>，sum<2>，i<2>}对应的程序模块“sum+＝b；i+＝1；b＝i*i；sum+＝b；i＝i-2；”。

本发明实施例提供一种面向多核处理器的程序划分方法，通过从源程序的数据结构中的入口节点开始，依次标记源程序的数据结构中的N个节点的层级，当该N个节点中层级为M的第一节点的计算量小于预设的第一计算量阈值时，根据第一节点的下依赖节点数量，从第一节点的依赖节点中确定备选节点集，该备选节点集中的每个备选节点的计算量与第一节点的计算量之和均小于等于第二计算量阈值，再根据预设规则，从该备选节点集中确定一个备选节点作为第一节点的目标节点，以及将第一节点和第一节点的目标节点合并为第二节点，将M加1后，重复执行上述节点的合并过程，直至该源程序的数据结构中的所有节点合并结束。由于源程序的数据结构中的N个节点表示源程序的N个语句，因此本发明实施例通过采用上述方法将源程序的数据结构中的N个节点合并为多个第二节点，可以将源程序划分为多个程序模块，其中，一个第二节点表示一个程序模块，一个程序模块包括至少一个语句，从而能够将整个程序划分为多个程序模块。且由于本发明实施例的面向多核处理器的程序划分方法可以应用于多种操作系统，并不限于主从线程模式的操作系统，因此本发明在对程序进行划分时无需依赖于操作系统。进而当划分后的多个程序模块映射到CMP执行时，可以更好地发挥CMP的并行处理性能。

实施例二

本发明实施例提供一种面向多核处理器的程序划分方法，如图4所示，该方法可以包括：

S201、开始。

S202、该编译器采用SSA技术，生成源程序的数据结构，该源程序的数据结构包括N个节点的数据结构，该N个节点中的每个节点的数据结构至少包括该节点的下依赖节点数量、该节点的下依赖节点、该节点的上依赖节点、该节点的上依赖节点数量、该节点的计算量，以及该节点的生命期，N≥1，N为整数。

具体的，该编译器通过对源程序采用SSA技术生成该源程序的数据结构的具体过程，可参见如图1所示的实施例中S101中的相关描述，此处不再赘述。

S203、该编译器为该N个节点中的每个节点分别分配存储地址。

S204、该编译器从源程序的数据结构中的入口节点开始，依次标记该源程序的数据结构中的N个节点的层级，该入口节点的层级为1，该入口节点为上依赖节点数量为0的节点。

具体的，该编译器从源程序的数据结构中的入口节点开始，依次标记该源程序的数据结构中的N个节点的层级的具体的实现方式，可以参见如图1所示的实施例中S101中的相关描述，此处不再赘述。

其中，源程序的数据结构中的入口节点可以有一个，也可以有多个，即层级为1的节点可以有一个，也可以有多个。

S205、从M＝1开始执行S206，M≤N，M为整数。

S206、若该N个节点中层级为M的第一节点的计算量小于预设的第一计算量阈值，则从S207开始继续执行；若该N个节点中层级为M的第一节点的计算量大于等于预设的第一计算量阈值，则执行S214，并继续执行。

S207、若该第一节点的下依赖节点数量大于1，则从S208开始继续执行；若该第一节点的下依赖节点数量为0，则从S210开始继续执行；若该第一节点的下依赖节点数量等于1，则从S212开始继续执行。

S208、该编译器从该第一节点的下依赖节点中确定备选节点集，该备选节点集中的每个备选节点的计算量与该第一节点的计算量之和均小于等于预设的第二计算量阈值。

S209、该编译器根据该备选节点集中的备选节点的层级，从该备选节点集中确定层级最小的至少一个备选节点，并根据该备选节点集中的备选节点的上依赖节点数量，从层级最小的至少一个备选节点中确定上依赖节点数量最大的一个备选节点作为第一节点的目标节点。从S215开始继续执行。

其中，由于节点的上依赖节点数量越大，表征该节点的通信量越大，因此选择上依赖节点数量最大的一个备选节点作为该第一节点的目标节点，与该第一节点进行合并，能够降低该第一节点与该第一节点的目标节点合并后形成的第二节点的通信量，进而降低该第二节点所表征的线程在该多核处理器中执行时的通信负荷。

S210、该编译器从该第一节点的上依赖节点中确定备选节点集，该备选节点集中的每个备选节点的计算量与该第一节点的计算量之和均小于等于预设的第二计算量阈值。

S211、该编译器根据该备选节点集中的备选节点的上依赖节点数量，从该备选节点集中确定上依赖节点数量最大的一个备选节点作为该第一节点的目标节点。从S215开始继续执行。

S212、若该下依赖节点的计算量与该第一节点的计算量之和小于等于预设的第二计算量阈值，则该编译器确定该一个下依赖节点为该第一节点的备选节点。

S213、该编译器将该备选节点作为该第一节点的目标节点。从S215开始继续执行。

S214、若该第一节点的下依赖节点数量大于等于1，则从S216开始继续执行；若该第一节点的下依赖节点数量为0，则从S218开始继续执行。

S215、该编译器将该第一节点和该第一节点的目标节点合并为第二节点，该第二节点的层级与该第一节点的目标节点的层级相同。

具体的，该编译器将该第一节点和该第一节点的目标节点合并为第二节点的合并过程，可参见如图1所示实施例中编译器将第一节点和一个目标节点合并为第二节点的合并过程的举例及描述，此处不再赘述。

其中，预设一个第一计算量阈值，当该第一节点的计算量小于该预设的第一计算量阈值时，该编译器对该第一节点进行合并，以及根据该预设的第一计算量阈值为该第一节点选择一个计算量最小的备选节点作为该第一节点的目标节点进行合并，是为了平衡该N个节点在合并完成之后形成的多个第二节点的计算量，进而平衡该多个第二节点所表征的多个线程中每个线程的计算量，以减小该多个线程中每个线程在多核处理器中执行时的处理负荷。

S216、该编译器将M加1。

S217、若循环没有结束，则返回S206继续执行，否则从S218开始继续执行。

S218、若存在下依赖节点数量和上依赖节点数量均为0的节点，则该编译器将下依赖节点数量和上依赖节点数量均为0的节点合并为一个第二节点。否则，执行S219。

S219、结束。

本发明实施例中，编译器可循环执行上述方法，对节点进行合并，当循环结束后，表示编译器已将源程序的数据结构中的N个节点合并为K个第二节点，即编译器已将源程序划分为K个程序模块，其中，循环结束后，每个第二节点对应一个程序模块。

可选的，如图5所示，上述S211还可以为：

S211a、该编译器根据该备选节点集中的备选节点的计算量，从该备选节点集中确定计算量最小的至少一个备选节点，并根据该备选节点集中的备选节点的上依赖节点数量，从计算量最小的至少一个备选节点中确定上依赖节点数量最大的一个备选节点作为该第一节点的目标节点。从S215开始继续执行。

可选的，若该源程序中存在满足仿射访问条件的循环，则该编译器可采用现有的仿射划分算法，对该循环进行划分，而对于该源程序中除该循环之外的程序，则可以采用本发明实施例提供的面向多核处理器的程序划分方法进行划分，这样能够保证对整个源程序的合理划分，从而改善对整个源程序的划分效果。其中，满足仿射访问条件的循环是指该循环的上边界、下边界和访问下标都为仿射函数的循环，其中，仿射函数可以为线性函数。

例如，如下所示的for循环：

该for循环的上边界i和下边界j都是由1至100线性变化，因此该for循环的上边界i和下边界j都是线性函数。且该for循环的访问下标x[i,j]＝x[i,j]+y[i-1,j]，访问下标y[i,j]＝y[i,j]+x[i,j-1]也均为线性函数，因此该for循环为满足仿射访问条件的循环，即该编译器可采用仿射划分算法对该循环进行划分。

下面举例说明对一个满足仿射访问条件的循环进行划分的过程。假设该循环的数据结构的示意图如图6(a)所示。首先将该循环的数据结构中，除入口节点c<0>和d<0>，以及出口节点a[0]<1>和b[0]<1>之外，且互相有依赖关系的至少一个节点作为一个合并节点，与其他节点进行合并，其中，多个合并节点之间无依赖关系，即如图6(b)所示的各个虚线圈标示的部分。编译器对该循环进行划分时，如图6(c)所示，将节点b[0]<0>和节点a[0]<0>作为节点T3；将节点b[1]<0>和节点a[1]<0>作为节点T4；将节点b[2]<0>和节点a[2]<0>作为节点T5；将节点c<0>为节点T1；将节点d<0>为节点T2；将节点a[0]<1>为节点T6；将节点b[0]<1>为节点T7。如图6(d)所示，该编译器将节点T1与其唯一的下依赖节点T3合并，形成节点T8；由于节点T2有两个下依赖节点，分别为节点T4和节点T5，因此该编译器可在节点T4和节点T5中随机选择一个节点，与节点T2合并，假设该编译器选择节点T4与节点T2合并形成节点T9。如图6(e)所示，然后该编译器将节点T8与其唯一的下依赖节点T6合并，形成节点T10；由于该编译器将节点T4与节点T6合并后，节点T9只有一个可以进行合并的下依赖节点T7，因此该编译器将节点T9与节点T7合并，形成节点T11。至此，该编译器通过仿射划分算法将该循环的数据结构中的所有节点合并为3个节点，分别为节点T5，节点T10和节点T11，该三个节点分别对应3个程序模块，该3个程序模块分别为：与节点T5对应的语句，与节点T10对应的语句，以及与节点T11对应的语句。

在本发明实施例中，该编译器对该源程序中的满足仿射访问条件的循环，可以采用现有的仿射划分算法进行划分，而对该源程序中除该循环之外的程序，则采用本发明实施例提供的面向多核处理器的程序划分方法进行划分，能够保证对整个源程序的合理划分，从而改善对整个源程序的划分效果。

进一步的，在循环结束，即将该N个节点合并为K个第二节点之后，该K个第二节点表征K个线程，对K个线程中的每个线程可以采用变量地址复用技术，以减小K个线程中每个线程中的程序在执行的过程中使用的内存空间，其中，1≤K＜N，K为整数。

具体的，若第一线程中的第一子节点的生命周期为0，且该第一子节点的下依赖节点数量为1，则可将该第一子节点的存储地址分配给第二子节点，此时，该第二子节点为该第一线程中该第一子节点的下依赖节点，该第一线程为所述K个线程中的一个。其中，该第一子节点的生命周期为该第一子节点的一个属性，可以理解为该第一子节点表征的变量，在程序执行过程中存在的时间段。进一步地，若与第一线程对应的第二节点为由下依赖节点数量和上依赖节点数量均为0的节点合并而成，则若第一线程中的第一子节点的生命周期为0，则可将该第一子节点的存储地址分配给第二子节点，此时，该第二子节点为该第一线程中除该第一子节点之外的任意一个子节点。

示例性的，若源程序的数据结构中的节点合并为2个节点，则该2个节点可分别表征第一线程和第二线程。该第一线程中包括4个子节点，分别为节点sum<0>，节点i<0>，节点b<0>和节点sum<1>。那么当点sum<0>的生命周期为0时，且由于节点sum<0>只有sum<1>一个下依赖节点，因此可以将节点sum<0>的存储地址分配给节点sum<1>。另一方面，当节点i<0>的生命周期为0时，且由于节点i<0>只有b<0>一个下依赖节点，因此可以将节点i<0>的存储地址分配给节点b<0>，当节点b<0>的生命周期为0时，且由于节点b<0>只有sum<1>一个下依赖节点，因此可以将节点b<0>的存储地址分配给节点sum<1>。通过对每个线程采用变量地址复用技术，能够减小每个线程中的语句在执行过程中使用的内存空间，进而节省该源程序在该多核处理器中并行执行时所占用的该多核处理器的内存空间。

进一步的，该编译器通过本发明实施例提供的面向多核处理器的程序划分方法，在循环结束，即将该N个节点合并为K个第二节点之后，该K个第二节点表征K个线程，该编译器将该K个线程分别映射到多核处理器中执行。

其中，该多核处理器可以采用无内部互锁流水级的微处理器(英文：microprocessorwithoutinterlockedpipedstages,缩写：MIPS)。具体的，该K个线程的通信数据在该多核处理器中的发送和接收过程可以包括：

(1)主线程对其他线程的控制通信

其中，根据该源程序的执行顺序，将该K个线程中首先执行的线程作为该K个线程的主线程。从该K个物理核的共享内存的首地址开始，依次为K个线程中的每个线程都分配一个地址，将该地址存入每个线程的工作完成标识中。例如，K个线程中，第i(i＝1,2，…，K)个线程在代码生成过程中，在代码声明之前，首先将该第i个线程的工作完成标识赋值为1，表示该第i个线程开始执行程序。当该第i个线程中的程序执行完毕后，将该第i个线程的工作完成标识赋值为0，之后该第i个线程通过执行一个空的循环，进入等待模式。而该主线程在该主线程中的程序执行完毕，并将该主线的工作完成标识赋值为0之后，依次检查该K个线程中除该主线程外的其他线程的工作标识，当该主线程检查到该K个线程中每个线程的工作完成标识都为0时，返回一个65535的值，表明该源程序全部执行完毕。

(2)该K个线程中的每个线程之间的数据通信

首先，为该K个线程中的每个线程在该共享内存中分配2个连续的地址：数据地址和锁地址。其中，在第i个线程中，2个连续的地址中的首地址作为该第i个线程的数据地址，用于存储该第i个线程将程序执行完毕后计算出的数据，2个连续的地址中的次地址作为该第i个线程的锁地址，用于表示该第i个线程将程序执行完毕后计算出的数据是否写入完毕。即在该第i个线程的代码声明之后就将该第i个线程的锁地址赋值为0，表示该数据还没有写入。当该数据写入完毕之后，再把该第i个线程的锁地址赋值为1，表示该数据已经写入完毕，至此，该第i个线程完成了一次数据输出。

示例性的，假设该第i个线程将该数据写入该数据地址的代码，以及该第i个线程为该锁地址赋值的代码可以表示为：

a[1]＝b[1]+1；//计算a[1]完毕

*(volatileint*)0x80012022＝a[1]；//将a[1]赋给该第i个线程的数据地址中

*(volatileint*)0x80012023＝1；//将该第i个线程的锁地址赋值为1

当该其他线程需要获取该第i个线程在程序执行完毕后生成的数据时，首先通过一个循环语句循环的判断该第i个线程的锁地址的值是否为1。该锁地址的值为0，表示该需要传输的数据还没写入完毕，则继续判断；该锁地址的值为1，则其他线程，将需要传输的数据读出，并使用。示例性的，其他线程检测该第i个线程锁地址的值，并使用需要传输的数据的代码可以表示为：

while(*(volatileint*)0x80012023＝＝0){}//检测该第i个线程锁地址的值

b[2]＝*(volatileint*)0x80012022；//使用该需要传输的数据

可选的，本发明实施例还提供另一种面向多核处理器的程序划分方法，具体为，每当层级为1的第一节点合并结束后，该编译器从合并后的程序的数据结构的入口节点开始，重新标记该数据结构中每个节点的层级，并对层级为1的第一节点进行合并。例如，在本实施例中，当层级为1的第一节点sum<0>和第一节点i<0>合并结束后，该编译器将节点{b<0>，i<0>}的层级标记为1，节点i<1>的层级标记为2，节点{sum<0>，sum<1>}的层级标记为3，其它节点依次重新标记层级，并对重新标记层级后该数据结构中层级为1的第一节点{b<0>，i<0>}进行合并。通过上述方案，编译器可以将原本为相同层级的节点{b<0>，i<0>}和节点i<1>，标定为不同层级的节点，以使得第一节点{b<0>，i<0>}能够与节点i<1>进行合并，即将原本有依赖关系且层级相同的节点标记为层级不同的节点，使得其能够进行合并。其中，本实施例中层级为1的第一节点的合并方法，与本发明上述实施例提供的一种面向多核处理器的程序划分方法中层级为M的第一节点的合并方法相同，此处不再赘述。

可选的，本发明实施例还提供又一种面向多核处理器的程序划分方法，具体为，每当层级为M的第一节点合并结束后，该编译器判断第M+1层的各个节点之间是否存在依赖关系。若存在依赖关系，则该编译器从合并后的程序的数据结构的入口节点开始，重新标记该数据结构中每个节点的层级，并从层级为1的第一节点开始进行合并；若不存在依赖关系，则按照本发明实施例提供的一种面向多核处理器的程序划分方法，对层级为M+1的第一节点继续进行合并。例如，在本实施例中，当层级为1的第一节点sum<0>和第一节点i<0>合并结束后，判断层级为2的节点之间是否存在依赖关系，由于层级为2的节点{b<0>，i<0>}和节点i<1>存在依赖关系，则编译器从该数据结构的入口节点{b<0>，i<0>}开始，重新标记该数据结构中每个节点的层级，通过上述方案，也能实现将原本有依赖关系且层级相同的节点标记为层级不同的节点，使得其能够进行合并。其中，本实施例中层级为M的第一节点的合并方法，与本发明上述实施例提供的一种面向多核处理器的程序划分方法中层级为M的第一节点的合并方法相同，此处不再赘述。

本发明实施例提供一种面向多核处理器的程序划分方法，通过从源程序的数据结构中的入口节点开始，依次标记源程序的数据结构中的N个节点的层级，当该N个节点中层级为M的第一节点的计算量小于预设的第一计算量阈值时，根据第一节点的下依赖节点数量，从第一节点的依赖节点中确定备选节点集，该备选节点集中的每个备选节点的计算量与第一节点的计算量之和均小于等于第二计算量阈值，再根据预设规则，从该备选节点集中确定一个备选节点作为第一节点的目标节点，以及将第一节点和第一节点的目标节点合并为第二节点，将M加1后，重复执行上述节点的合并过程，直至该源程序的数据结构中的所有节点合并结束。由于源程序的数据结构中的N个节点表示源程序的N个语句，因此本发明实施例通过采用上述方法将源程序的数据结构中的N个节点合并为多个第二节点，可以将源程序划分为多个程序模块，其中，一个第二节点表示一个程序模块，一个程序模块包括至少一个语句，从而能够将整个程序划分为多个程序模块。且由于本发明实施例的面向多核处理器的程序划分方法可以应用于多种操作系统，并不限于主从线程模式的操作系统，因此本发明在对程序进行划分时无需依赖于操作系统。进而当划分后的多个程序模块映射到CMP执行时，可以更好地发挥CMP的并行处理性能。

实施例三

如图7所示，本发明实施例提供一种面向多核处理器的程序划分装置，该程序划分装置可以包括：

标记单元10，用于从源程序的数据结构中的入口节点开始，依次标记所述源程序的数据结构中的N个节点的层级，所述入口节点的层级为1，所述入口节点为上依赖节点数量为0的节点，N≥1，N为整数。

执行单元11，用于由M＝1开始循环执行S1-S4，直至循环结束，M≤N，M为整数；

S1：若所述N个节点中所述标记单元10标记的层级为M的第一节点的计算量小于预设的第一计算量阈值，则根据所述第一节点的下依赖节点数量，从所述第一节点的依赖节点中确定备选节点集，所述备选节点集中的每个备选节点的计算量与所述第一节点的计算量之和均小于等于预设的第二计算量阈值；

S2：根据预设规则，从所述备选节点集中确定一个备选节点作为所述第一节点的目标节点；

S3：将所述第一节点和所述第一节点的目标节点合并为第二节点，所述第二节点的层级与所述第一节点的目标节点的层级相同；

S4：将M加1。

可选的，所述执行单元11，具体用于若所述第一节点的下依赖节点数量大于等于1，则从所述第一节点的下依赖节点中确定备选节点集。

可选的，所述执行单元11，具体用于若所述第一节点的下依赖节点数量为0，则从所述第一节点的上依赖节点中确定备选节点集。

可选的，所述第一节点的下依赖节点数量为1，所述备选节点集中包括一个备选节点，

所述执行单元11，具体用于将所述一个备选节点作为所述第一节点的目标节点。

可选的，所述第一节点的下依赖节点数量大于1，所述预设规则为备选节点的层级和备选节点的上依赖节点数量，

所述执行单元11，具体用于根据所述备选节点的层级，从所述备选节点集中确定层级最小的至少一个备选节点，并根据所述备选节点的上依赖节点数量，从所述层级最小的至少一个备选节点中确定上依赖节点数量最大的所述一个备选节点，作为所述第一节点的目标节点。

可选的，所述第一节点的下依赖节点数量为0，所述预设规则为备选节点的上依赖节点数量，

所述执行单元11，具体用于根据所述备选节点的上依赖节点数量，从所述备选节点集中确定上依赖节点数量最大的所述一个备选节点作为所述第一节点的目标节点。

可选的，所述第一节点的下依赖节点数量为0，所述预设规则为备选节点的计算量和备选节点的上依赖节点数量，

所述执行单元11，具体用于根据所述备选节点的计算量，从所述备选节点集中确定计算量最小的至少一个备选节点，并根据所述备选节点的上依赖节点数量，从所述计算量最小的至少一个备选节点中确定上依赖节点数量最大的所述一个备选节点，作为所述第一节点的目标节点。

可选的，如图8所示，所述程序划分装置还包括：

生成单元12，用于在所述标记单元10从源程序的数据结构中的入口节点开始，依次标记所述源程序的数据结构中的N个节点的层级之前，采用SSA技术，生成所述源程序的数据结构，所述源程序的数据结构包括所述N个节点的数据结构，所述N个节点中的每个节点的数据结构至少包括所述节点的下依赖节点、所述节点的下依赖节点数量、所述节点的上依赖节点、所述节点的计算量，以及所述节点的生命期。

可选的，所述执行单元11，具体用于根据所述第一节点的数据结构和所述第一节点的目标节点的数据结构，确定所述第二节点的数据结构，所述第二节点的数据结构中包括所述第二节点的层级。

可选的，所述执行单元11，还用于执行S5，

S5：若所述第一节点的计算量大于等于所述第一计算量阈值，且所述第一节点的下依赖节点数量大于等于1，则执行S4。

可选的，所述执行单元11，还用于执行S6，

S6：若所述第一节点的计算量大于等于所述第一计算量阈值，且所述第一节点的下依赖节点数量为0，则结束循环。

可选的，所述执行单元11，还用于将下依赖节点数量和上依赖节点数量均为0的所有节点合并为所述第二节点。

可选的，如图9所示，所述程序划分装置还包括：

分配单元13，用于在所述生成单元12采用SSA技术，生成所述源程序的数据结构之后，为所述N个节点中的每个节点分别分配存储地址。

可选的，在所述执行单元11执行循环结束后，所述N个节点合并为K个第二节点，所述K个第二节点表征K个线程，1≤K＜N，K为整数，

所述分配单元13，还用于若第一线程中的第一子节点的生命周期为0，且所述第一子节点的下依赖节点数量为1，则将所述第一子节点的存储地址分配给第二子节点，所述第二子节点为所述第一线程中的所述第一子节点的下依赖节点，所述第一线程为所述K个线程中的一个。

本发明实施例提供一种面向多核处理器的程序划分装置，该程序划分装置通过从源程序的数据结构中的入口节点开始，依次标记源程序的数据结构中的N个节点的层级，当该N个节点中层级为M的第一节点的计算量小于预设的第一计算量阈值时，该程序划分装置根据第一节点的下依赖节点数量，从第一节点的依赖节点中确定备选节点集，该备选节点集中的每个备选节点的计算量与第一节点的计算量之和均小于等于第二计算量阈值，该程序划分装置再根据预设规则，从该备选节点集中确定一个备选节点作为第一节点的目标节点，以及将第一节点和第一节点的目标节点合并为第二节点，第二节点的层级与第一节点的目标节点的层级相同，将M加1后，该程序划分装置重复执行上述节点的合并过程，直至该源程序的数据结构中的所有节点合并结束。由于源程序的数据结构中的N个节点表示源程序的N个语句，因此本发明实施例通过采用上述方法将源程序的数据结构中的N个节点合并为多个第二节点，可以将源程序划分为多个程序模块，其中，一个第二节点表示一个程序模块，一个程序模块包括至少一个语句，从而能够将整个程序划分为多个程序模块。且由于本发明实施例的面向多核处理器的程序划分方法可以应用于多种操作系统，并不限于主从线程模式的操作系统，因此本发明在对程序进行划分时无需依赖于操作系统。进而当划分后的多个程序模块映射到CMP执行时，可以更好地发挥CMP的并行处理性能。

实施例四

如图10所示，本发明实施例提供一种面向多核处理器的程序划分装置，该程序划分装置可以为编译器，该编译器可以包括硬件实体和软件环境。该硬件实体可以为中央处理器(英文：centralprocessingunit，缩写：CPU)20；该软件环境可以为内存21。该编译器运行在CPU20中。

其中，所述内存21，用于作为所述CPU20的缓存，存储所述CPU20执行图1、图4和图5所需的程序代码及信息代码。

所述CPU20，耦合至所述内存21，所述CPU20通过执行所述内存21中存储的程序代码，并调用所述内存21中存储的信息代码，完成图1、图4和图5任意之一所述的程序划分方法流程。

具体的，所述CPU20，用于从源程序的数据结构中的入口节点开始，依次标记所述源程序的数据结构中的N个节点的层级，所述入口节点的层级为1，所述入口节点为上依赖节点数量为0的节点，N≥1，N为整数；并由M＝1开始循环执行S1-S4，直至循环结束，M≤N，M为整数；

S1：若所述N个节点中层级为M的第一节点的计算量小于预设的第一计算量阈值，则根据所述第一节点的下依赖节点数量，从所述第一节点的依赖节点中确定备选节点集，所述备选节点集中的每个备选节点的计算量与所述第一节点的计算量之和均小于等于预设的第二计算量阈值；

S2：根据预设规则，从所述备选节点集中确定一个备选节点作为所述第一节点的目标节点；

S3：将所述第一节点和所述第一节点的目标节点合并为第二节点，所述第二节点的层级与所述第一节点的目标节点的层级相同；

S4：将M加1。

所述内存21，用于存储所述源程序、所述源程序的数据结构、所述第一计算量阈值、所述第二计算量阈值等信息代码，以及所述CPU20完成上述程序划分过程的程序代码，所述CPU20通过执行所述程序代码，并调用所述信息代码，完成上述程序划分过程。

可选的，所述CPU20，具体用于若所述第一节点的下依赖节点数量大于等于1，则从所述第一节点的下依赖节点中确定备选节点集。

可选的，所述CPU20，具体用于若所述第一节点的下依赖节点数量为0，则从所述第一节点的上依赖节点中确定备选节点集。

可选的，所述第一节点的下依赖节点数量为1，所述备选节点集中包括一个备选节点，

所述CPU20，具体用于将所述一个备选节点作为所述第一节点的目标节点。

可选的，所述第一节点的下依赖节点数量大于1，所述预设规则为备选节点的层级和备选节点的上依赖节点数量，

所述CPU20，具体用于根据所述备选节点的层级，从所述备选节点集中确定层级最小的至少一个备选节点，并根据所述备选节点的上依赖节点数量，从所述层级最小的至少一个备选节点中确定上依赖节点数量最大的所述一个备选节点，作为所述第一节点的目标节点。

可选的，所述第一节点的下依赖节点数量为0，所述预设规则为备选节点的上依赖节点数量，

所述CPU20，具体用于根据所述备选节点的上依赖节点数量，从所述备选节点集中确定上依赖节点数量最大的所述一个备选节点作为所述第一节点的目标节点。

可选的，所述第一节点的下依赖节点数量为0，所述预设规则为备选节点的计算量和备选节点的上依赖节点数量，

所述CPU20，具体用于根据所述备选节点的计算量，从所述备选节点集中确定计算量最小的至少一个备选节点，并根据所述备选节点的上依赖节点数量，从所述计算量最小的至少一个备选节点中确定上依赖节点数量最大的所述一个备选节点，作为所述第一节点的目标节点。

可选的，所述CPU20，还用于在从源程序的数据结构中的入口节点开始，依次标记所述源程序的数据结构中的N个节点的层级之前，采用SSA技术，生成所述源程序的数据结构，所述源程序的数据结构包括所述N个节点的数据结构，所述N个节点中的每个节点的数据结构至少包括所述节点的下依赖节点、所述节点的下依赖节点数量、所述节点的上依赖节点、所述节点的计算量，以及所述节点的生命期。

可选的，所述CPU20，具体用于根据所述第一节点的数据结构和所述第一节点的目标节点的数据结构，确定所述第二节点的数据结构，所述第二节点的数据结构中包括所述第二节点的层级。

可选的，所述CPU20，还用于执行S5，

S5：若所述第一节点的计算量大于等于所述第一计算量阈值，且所述第一节点的下依赖节点数量大于等于1，则执行S4。

可选的，所述CPU20，还用于执行S6，

S6：若所述第一节点的计算量大于等于所述第一计算量阈值，且所述第一节点的下依赖节点数量为0，则结束循环。

可选的，所述CPU20，还用于将下依赖节点数量和上依赖节点数量均为0的所有节点合并为所述第二节点。

可选的，所述CPU20，还用于在采用SSA技术，生成所述源程序的数据结构之后，为所述N个节点中的每个节点分别分配存储地址。

可选的，在所述CPU20执行循环结束后，所述N个节点合并为K个第二节点，所述K个第二节点表征K个线程，1≤K＜N，K为整数，

所述CPU20，还用于若第一线程中的第一子节点的生命周期为0，且所述第一子节点的下依赖节点数量为1，则将所述第一子节点的存储地址分配给第二子节点，所述第二子节点为所述第一线程中的所述第一子节点的下依赖节点，所述第一线程为所述K个线程中的一个。

本发明实施例提供一种面向多核处理器的程序划分装置，该程序划分装置通过从源程序的数据结构中的入口节点开始，依次标记源程序的数据结构中的N个节点的层级，当该N个节点中层级为M的第一节点的计算量小于预设的第一计算量阈值时，该程序划分装置根据第一节点的下依赖节点数量，从第一节点的依赖节点中确定备选节点集，该备选节点集中的每个备选节点的计算量与第一节点的计算量之和均小于等于第二计算量阈值，该程序划分装置再根据预设规则，从该备选节点集中确定一个备选节点作为第一节点的目标节点，以及将第一节点和第一节点的目标节点合并为第二节点，第二节点的层级与第一节点的目标节点的层级相同，将M加1后，该程序划分装置重复执行上述节点的合并过程，直至该源程序的数据结构中的所有节点合并结束。由于源程序的数据结构中的N个节点表示源程序的N个语句，因此本发明实施例通过采用上述方法将源程序的数据结构中的N个节点合并为多个第二节点，可以将源程序划分为多个程序模块，其中，一个第二节点表示一个程序模块，一个程序模块包括至少一个语句，从而能够将整个程序划分为多个程序模块。且由于本发明实施例的面向多核处理器的程序划分方法可以应用于多种操作系统，并不限于主从线程模式的操作系统，因此本发明在对程序进行划分时无需依赖于操作系统。进而当划分后的多个程序模块映射到CMP执行时，可以更好地发挥CMP的并行处理性能。

所属领域的技术人员可以清楚地了解到，为描述的方便和简洁，仅以上述各功能模块的划分进行举例说明，实际应用中，可以根据需要而将上述功能分配由不同的功能模块完成，即将装置的内部结构划分成不同的功能模块，以完成以上描述的全部或者部分功能。上述描述的系统，装置和单元的具体工作过程，可以参考前述方法实施例中的对应过程，此处不再赘述。

在本申请所提供的几个实施例中，应该理解到，所揭露的系统，装置和方法，可以通过其它的方式实现。例如，以上所描述的装置实施例仅仅是示意性的，例如，所述模块或单元的划分，仅仅为一种逻辑功能划分，实际实现时可以有另外的划分方式，例如多个单元或组件可以结合或者可以集成到另一个系统，或一些特征可以忽略，或不执行。另一点，所显示或讨论的相互之间的耦合或直接耦合或通信连接可以是通过一些接口，装置或单元的间接耦合或通信连接，可以是电性，机械或其它的形式。

所述作为分离部件说明的单元可以是或者也可以不是物理上分开的，作为单元显示的部件可以是或者也可以不是物理单元，即可以位于一个地方，或者也可以分布到多个网络单元上。可以根据实际的需要选择其中的部分或者全部单元来实现本实施例方案的目的。

另外，在本发明各个实施例中的各功能单元可以集成在一个处理单元中，也可以是各个单元单独物理存在，也可以两个或两个以上单元集成在一个单元中。上述集成的单元既可以采用硬件的形式实现，也可以采用软件功能单元的形式实现。

所述集成的单元如果以软件功能单元的形式实现并作为独立的产品销售或使用时，可以存储在一个计算机可读取存储介质中。基于这样的理解，本发明的技术方案本质上或者说对现有技术做出贡献的部分或者该技术方案的全部或部分可以以软件产品的形式体现出来，该计算机软件产品存储在一个存储介质中，包括若干指令用以使得一台计算机设备(可以是个人计算机，服务器，或者网络设备等)或处理器执行本发明各个实施例所述方法的全部或部分步骤。而前述的存储介质包括：U盘、移动硬盘、ROM、RAM、磁碟或者光盘等各种可以存储程序代码的介质。

以上所述，仅为本发明的具体实施方式，但本发明的保护范围并不局限于此，任何熟悉本技术领域的技术人员在本发明揭露的技术范围内，可轻易想到变化或替换，都应涵盖在本发明的保护范围之内。因此，本发明的保护范围应所述以权利要求的保护范围为准。

Claims (28)

1.一种面向多核处理器的程序划分方法，其特征在于，包括：

从源程序的数据结构中的入口节点开始，依次标记所述源程序的数据结构中的N个节点的层级，所述入口节点的层级为1，所述入口节点为上依赖节点数量为0的节点，N≥1，N为整数；

由M＝1开始循环执行S1-S4，直至循环结束，M≤N，M为整数；

S1：若所述N个节点中层级为M的第一节点的计算量小于预设的第一计算量阈值，则根据所述第一节点的下依赖节点数量，从所述第一节点的依赖节点中确定备选节点集，所述备选节点集中的每个备选节点的计算量与所述第一节点的计算量之和均小于等于预设的第二计算量阈值；

S2：根据预设规则，从所述备选节点集中确定一个备选节点作为所述第一节点的目标节点；

S3：将所述第一节点和所述第一节点的目标节点合并为第二节点，所述第二节点的层级与所述第一节点的目标节点的层级相同；

S4：将M加1。

2.根据权利要求1所述的方法，其特征在于，所述S1中根据所述第一节点的下依赖节点数量，从所述第一节点的依赖节点中确定备选节点集，包括：

若所述第一节点的下依赖节点数量大于等于1，则从所述第一节点的下依赖节点中确定备选节点集。

3.根据权利要求1或2所述的方法，其特征在于，所述S1中根据所述第一节点的下依赖节点数量，从所述第一节点的依赖节点中确定备选节点集，包括：

若所述第一节点的下依赖节点数量为0，则从所述第一节点的上依赖节点中确定备选节点集。

4.根据权利要求1-3任一项所述的方法，其特征在于，所述第一节点的下依赖节点数量为1，所述备选节点集中包括一个备选节点，

其中，所述S2中根据预设规则，从所述备选节点集中确定一个备选节点作为所述第一节点的目标节点，包括：

将所述一个备选节点作为所述第一节点的目标节点。

5.根据权利要求1-4任一项所述的方法，其特征在于，所述第一节点的下依赖节点数量大于1，所述预设规则为备选节点的层级和备选节点的上依赖节点数量，

其中，所述S2中根据预设规则，从所述备选节点集中确定一个备选节点作为所述第一节点的目标节点，包括：

根据所述备选节点的层级，从所述备选节点集中确定层级最小的至少一个备选节点；

根据所述备选节点的上依赖节点数量，从所述层级最小的至少一个备选节点中确定上依赖节点数量最大的所述一个备选节点，作为所述第一节点的目标节点。

6.根据权利要求1-5任一项所述的方法，其特征在于，所述第一节点的下依赖节点数量为0，所述预设规则为备选节点的上依赖节点数量，

其中，所述S2中根据预设规则，从所述备选节点集中确定一个备选节点作为所述第一节点的目标节点，包括：

根据所述备选节点的上依赖节点数量，从所述备选节点集中确定上依赖节点数量最大的所述一个备选节点作为所述第一节点的目标节点。

7.根据权利要求1-5任一项所述的方法，其特征在于，所述第一节点的下依赖节点数量为0，所述预设规则为备选节点的计算量和备选节点的上依赖节点数量，

其中，所述S2中根据预设规则，从所述备选节点集中确定一个备选节点作为所述第一节点的目标节点，包括：

根据所述备选节点的计算量，从所述备选节点集中确定计算量最小的至少一个备选节点；

根据所述备选节点的上依赖节点数量，从所述计算量最小的至少一个备选节点中确定上依赖节点数量最大的所述一个备选节点，作为所述第一节点的目标节点。

8.根据权利要求1-7任一项所述的方法，其特征在于，所述从源程序的数据结构中的入口节点开始，依次标记所述源程序的数据结构中的N个节点的层级之前，所述方法还包括：

采用静态单赋值SSA技术，生成所述源程序的数据结构，所述源程序的数据结构包括所述N个节点的数据结构，所述N个节点中的每个节点的数据结构至少包括所述节点的下依赖节点、所述节点的下依赖节点数量、所述节点的上依赖节点、所述节点的计算量，以及所述节点的生命期。

9.根据权利要求8所述的方法，其特征在于，所述S3中将所述第一节点和所述第一节点的目标节点合并为第二节点，包括：

根据所述第一节点的数据结构和所述第一节点的目标节点的数据结构，确定所述第二节点的数据结构，所述第二节点的数据结构中包括所述第二节点的层级。

10.根据权利要求1-9任一项所述的方法，其特征在于，所述方法还包括：

S5：若所述第一节点的计算量大于等于所述第一计算量阈值，且所述第一节点的下依赖节点数量大于等于1，则执行S4。

11.根据权利要求1-10任一项所述的方法，其特征在于，所述方法还包括：

S6：若所述第一节点的计算量大于等于所述第一计算量阈值，且所述第一节点的下依赖节点数量为0，则结束循环。

12.根据权利要求1-11任一项所述的方法，其特征在于，所述方法还包括：

将下依赖节点数量和上依赖节点数量均为0的所有节点合并为所述第二节点。

13.根据权利要求8所述的方法，其特征在于，所述采用SSA技术，生成所述源程序的数据结构之后，所述方法还包括：

为所述N个节点中的每个节点分别分配存储地址。

14.根据权利要求13所述的方法，其特征在于，在循环结束后，所述N个节点合并为K个第二节点，所述K个第二节点表征K个线程，1≤K＜N，K为整数，所述方法还包括：

若第一线程中的第一子节点的生命周期为0，且所述第一子节点的下依赖节点数量为1，则将所述第一子节点的存储地址分配给第二子节点，所述第二子节点为所述第一线程中的所述第一子节点的下依赖节点，所述第一线程为所述K个线程中的一个。

15.一种面向多核处理器的程序划分装置，其特征在于，包括：

标记单元，用于从源程序的数据结构中的入口节点开始，依次标记所述源程序的数据结构中的N个节点的层级，所述入口节点的层级为1，所述入口节点为上依赖节点数量为0的节点，N≥1，N为整数；

执行单元，用于由M＝1开始循环执行S1-S4，直至循环结束，M≤N，M为整数；

S1：若所述N个节点中所述标记单元标记的层级为M的第一节点的计算量小于预设的第一计算量阈值，则根据所述第一节点的下依赖节点数量，从所述第一节点的依赖节点中确定备选节点集，所述备选节点集中的每个备选节点的计算量与所述第一节点的计算量之和均小于等于预设的第二计算量阈值；

S2：根据预设规则，从所述备选节点集中确定一个备选节点作为所述第一节点的目标节点；

S3：将所述第一节点和所述第一节点的目标节点合并为第二节点，所述第二节点的层级与所述第一节点的目标节点的层级相同；

S4：将M加1。

16.根据权利要求15所述的程序划分装置，其特征在于，

所述执行单元，具体用于若所述第一节点的下依赖节点数量大于等于1，则从所述第一节点的下依赖节点中确定备选节点集。

17.根据权利要求15或16所述的程序划分装置，其特征在于，

所述执行单元，具体用于若所述第一节点的下依赖节点数量为0，则从所述第一节点的上依赖节点中确定备选节点集。

18.根据权利要求15-17任一项所述的程序划分装置，其特征在于，所述第一节点的下依赖节点数量为1，所述备选节点集中包括一个备选节点，

所述执行单元，具体用于将所述一个备选节点作为所述第一节点的目标节点。

19.根据权利要求15-18任一项所述的程序划分装置，其特征在于，所述第一节点的下依赖节点数量大于1，所述预设规则为备选节点的层级和备选节点的上依赖节点数量，

所述执行单元，具体用于根据所述备选节点的层级，从所述备选节点集中确定层级最小的至少一个备选节点，并根据所述备选节点的上依赖节点数量，从所述层级最小的至少一个备选节点中确定上依赖节点数量最大的所述一个备选节点，作为所述第一节点的目标节点。

20.根据权利要求15-19任一项所述的程序划分装置，其特征在于，所述第一节点的下依赖节点数量为0，所述预设规则为备选节点的上依赖节点数量，

所述执行单元，具体用于根据所述备选节点的上依赖节点数量，从所述备选节点集中确定上依赖节点数量最大的所述一个备选节点作为所述第一节点的目标节点。

21.根据权利要求15-19任一项所述的程序划分装置，其特征在于，所述第一节点的下依赖节点数量为0，所述预设规则为备选节点的计算量和备选节点的上依赖节点数量，

所述执行单元，具体用于根据所述备选节点的计算量，从所述备选节点集中确定计算量最小的至少一个备选节点，并根据所述备选节点的上依赖节点数量，从所述计算量最小的至少一个备选节点中确定上依赖节点数量最大的所述一个备选节点，作为所述第一节点的目标节点。

22.根据权利要求15-21任一项所述的程序划分装置，其特征在于，所述程序划分装置还包括：

生成单元，用于在所述标记单元从源程序的数据结构中的入口节点开始，依次标记所述源程序的数据结构中的N个节点的层级之前，采用静态单赋值SSA技术，生成所述源程序的数据结构，所述源程序的数据结构包括所述N个节点的数据结构，所述N个节点中的每个节点的数据结构至少包括所述节点的下依赖节点、所述节点的下依赖节点数量、所述节点的上依赖节点、所述节点的计算量，以及所述节点的生命期。

23.根据权利要求22所述的程序划分装置，其特征在于，

所述执行单元，具体用于根据所述第一节点的数据结构和所述第一节点的目标节点的数据结构，确定所述第二节点的数据结构，所述第二节点的数据结构中包括所述第二节点的层级。

24.根据权利要求15-23任一项所述的程序划分装置，其特征在于，

所述执行单元，还用于执行S5，

S5：若所述第一节点的计算量大于等于所述第一计算量阈值，且所述第一节点的下依赖节点数量大于等于1，则执行S4。

25.根据权利要求15-24任一项所述的程序划分装置，其特征在于，

所述执行单元，还用于执行S6，

S6：若所述第一节点的计算量大于等于所述第一计算量阈值，且所述第一节点的下依赖节点数量为0，则结束循环。

26.根据权利要求15-25任一项所述的程序划分装置，其特征在于，

所述执行单元，还用于将下依赖节点数量和上依赖节点数量均为0的所有节点合并为所述第二节点。

27.根据权利要求22所述的程序划分装置，其特征在于，所述程序划分装置还包括：

分配单元，用于在所述生成单元采用SSA技术，生成所述源程序的数据结构之后，为所述N个节点中的每个节点分别分配存储地址。

28.根据权利要求27所述的程序划分装置，其特征在于，在所述执行单元执行循环结束后，所述N个节点合并为K个第二节点，所述K个第二节点表征K个线程，1≤K＜N，K为整数，

所述分配单元，还用于若第一线程中的第一子节点的生命周期为0，且所述第一子节点的下依赖节点数量为1，则将所述第一子节点的存储地址分配给第二子节点，所述第二子节点为所述第一线程中的所述第一子节点的下依赖节点，所述第一线程为所述K个线程中的一个。