CN101950282B - 一种多处理器系统及其同步引擎 - Google Patents

Abstract

本发明公开了一种多处理器系统及其同步引擎。所述同步引擎包括：多个存储队列，一个队列存储来自一个处理器的所有同步原语；多个调度模块，在多个存储队列中选定用于执行的同步原语之后，根据同步原语的类型，发送到相对应的处理模块进行处理，调度模块与存储队列一一对应；多个处理模块，接收调度模块发来的同步原语，执行不同功能；虚拟同步存储结构模块，使用少量的存储空间，通过控制逻辑把所有处理器的直属存储空间都映射为同步存储结构来实现各种同步原语的功能；主存端口，与虚拟同步存储结构模块进行通讯，对各处理器的直属存储进行读和写，以及向处理器发起中断；配置寄存器，存储处理模块需要用到的各种配置信息。

Description

一种多处理器系统及其同步引擎

技术领域

本发明涉及并行程序数据处理技术领域，特别是涉及一种多处理器系统及其同步引擎。

背景技术

在并行程序中，多个进程/线程(以下统称进程)并行协同工作，完成处理任务。多个进程在其运行周期中，需要使用同步原语来实现多个进程之间的同步。同步原语是保证并行程序正确性的关键原语。并行程序中常用的具有同步含义的原语有Lock和Barrier。图1是并行程序中使用Barrier同步原语实现读写次序的例子示意图，如图1所示，同步原语Barrier可以保证进程P2在读取变量A的值时，读到的值一定是进程P1写入的值。Lock原语在科学计算中一般是用来保证多个进程之间对某种资源的互斥访问。它的实现一般依赖于处理器提供的特殊指令来实现，比如典型的LL/SC指令。

除了Barrier和Lock这种只包含同步含义的原语以外，在并行程序中还有其他一些常用的，隐含同步的原语，如Reduce或者All-Reduce原语。Reduce原语可以简单地表示为Reduce(Root，A_i，Op，Com)，其中Root表示这次Reduce运算的根进程；A_i表示进程i参与Reduce的源数据；Op表示Reduce的运算模式，常见的有“加”、“减”、“最大”、“最小”等；Com表示参与这个Reduce的进程的集合。Reduce(Root，A_i，Op，Com)的含义如下：在集合Com内的每个进程i的数据A_i，均使用Op模式进行运算，并把运算结果返回至Root。在这个Reduce运算中，隐含了Com集合中所有进程和Root进程的同步关系，即Root进程必须在所有Com集合内的进程到达某个时间点之后，才能获得最终的运算结果，并且在实现同步的同时，也实现了数据在进程间的移动。All-Reduce与Reduce的区别仅仅在于最后的计算结果是广播到Com内所有进程，而不仅仅是Root。在下文中除了特别说明，All-Reduce和Reduce都统称Reduce。

现有技术中使用软件实现上述同步原语具有较好的灵活性，但是执行效率较低，主要体现在启动开销大，执行速度慢，进程间通信次数多。比如软件实现的Barrier可以用类似于计数器的方法，使用一个共享内存的计数器A，A被Root进程初始化为0，然后每个参与Barrier的进程都执行A＝A+1的操作，然后不断在循环中读取A的值，当A的值等于参与Barrier的进程总数的时候，即表明所有进程都达到了同步。这种软件实现的方法有两个问题，一个是在执行A＝A+1的时候，由于A是共享的，可能被多个进程同时操作，因此每个进程都要保证自己的操作是原子操作，因此需要用或者是锁技术，或者是锁内存总线的方法来保证原子操作，而这些操作都是很费时，并且影响处理器性能的操作；另外一个问题在于各个进程在循环中读取A的值，由于A是分配在某个处理器的内存上的，在多处理器的环境下，如果多处理器间有Cache一致性保证，会导致大量的Cache一致性控制信息在处理器间交换；如果没有Cache一致性保证，循环读取A值的时候会引起大量的远程Load操作，无论哪种情况都会导致多处理器的通信带宽被大量占用，从而影响系统性能。

一种软件实现的Reduce算法与上述Barrier类似，除了计算是否所有进程都达到同步点以外，还要对各个进程的数据进行计算，计算的结果存放在共享内存的变量Value中。假设进程0的数据为Value0，进程1的数据为Value1…进程N的数据为ValueN。Root进程根据Reduce的操作类型初始化Value，比如Reduce的操作类型是“最大”，则把Value初始化为计算机能够表示的最小值，然后每个进程n进行如下操作：

if(Value n大于Value)

Value＝Value n；

同样的，每个进程需要保证上述操作的原子性，这样当所有进程都通过Barrier所述的计数器A判断完成计算后，Value的最终值就是所有进程的数据中最大的的那个值，每个进程就可以读取Value的值了，也就是完成了操作类型为“最大”的Reduce。

与Barrier类似的，软件实现多个处理器间的Reduce，Lock操作也有类型问题。虽然软件使用一些改进算法可以减少上述的缺点，但是仍然不能从根本上解决问题，仍然存在执行次数慢，消耗处理器执行资源等问题。

发明内容

本发明的目的在于提供一种多处理器系统及其同步引擎。其能够很好地在多处理器环境下支持各种常用同步操作，具有执行速度快，占用处理器通信带宽小，无论处理器间是否有Cache一致性都能适用等优点；同时由于所述的同步引擎是硬件实现的设备，计算需要的原子性很容易得到保证。

为实现本发明的目的而提供的一种多处理器的同步引擎，包括：

多个存储队列，用于接收多个处理器发送的同步原语，一个队列存储来自一个处理器的所有同步原语；

多个调度模块，用于在所述多个存储队列中选定用于执行的同步原语之后，根据同步原语的类型，发送到相对应的处理模块进行处理，所述调度模块与所述存储队列一一对应；

多个处理模块，用于接收所述调度模块发来的同步原语，执行不同功能；

虚拟同步存储结构模块，使用少量的存储空间，通过控制逻辑把所有处理器的直属存储空间都映射为同步存储结构来实现各种同步原语的功能；

主存端口，用于与所述虚拟同步存储结构模块进行通讯，对各处理器的直属存储进行读和写，以及向所述处理器发起中断；

配置寄存器，用于存储所述处理模块需要用到的各种配置信息。

在同步原语存储到对应的存储队列里时，将同时保存进程号信息，以区别同一处理器上不同进程发送过来的同步原语。

所述处理模块，包括：Reduce处理模块、Barrier处理模块、Load/Store处理模块，以及Put/Get处理模块。

所述同步引擎中的处理模块，能够根据同步引擎支持的同步原语的类型进行扩展。

所述同步存储结构是使用少量的片内存储虚拟出来的，并不直接占用处理器直属存储的空间。

所述同步存储结构是{Count，P，L，Value}，{Count，P，L，}称为同步存储的Tag，Count和Value的位宽可以根据系统需求进行不同的设定；Value：存储单元，用于存储数据，L：Lock标志位，用于支持Lock/Unlock原语；P：Produce标志位，用于实现Put/Get原语，Count：计数器，用于实现Barrier原语、Reduce原语，以及多种模式的Put/Get原语。计数器的位宽和同步引擎支持的最大并行进程有关，n位Count可以支持最大2ⁿ个进程。

所述同步存储结构的虚拟方法是：使用一块片内存储作为哈希表，哈希表中每一项的结构为{关键值，Tag，Value}，当处理模块写入一项同步存储结构时，所述处理模块执行指令，把指令的地址作为关键值，使用哈希算法在哈希表内选择一行作为存储单元，把同步结构存储下来；当处理模块读取一项同步存储结构时，同样使用哈希算法找到对应于这个地址的项，哈希表输出找到的那一行的内容{Tag，Value}；如果读取过程中使用哈希算法没有找到对应的项，则说明当前指令应该暂缓执行，则指令被重新回归相应的存储队列中，等候下次调度执行；在同步原语被执行后，如果同步存储结构的Tag的执行结果等于全0，则说明这一项同步存储结构已经被完全执行完毕，则在哈希表中释放对应的存储空间；当所述哈希表溢出的时候，则使用所述主存端口向对应的处理器发送中断，在所述处理器直属内存中构造哈希表，来存储所述同步存储结构。

为实现本发明的目的还提供一种采用所述的多处理器的同步引擎的多处理器系统，其特征在于，所述系统，包括：多个处理器和一个处理芯片，其中：

所述处理芯片，包括：

多个设备端口，用于和所述多个处理器高速互联，每个处理器和一个设备端口连接；

所述同步引擎，其中，所述存储队列与所述多个设备端口互联。

在设备发现过程中，每个处理器通过标准设备搜索流程搜索到与之互联的设备端口，并分配设备端口申请的各种资源；所述同步引擎把自身的资源通过设备端口映射到对应的处理器的操作系统中，在多个处理器上的软件通过映射关系操作所述同步引擎，所述同步引擎被多个处理器共享。

为实现本发明的目的还提供一种所述多处理器的同步引擎对于Barrier原语的处理方法，所述方法，包括下列步骤：

110.同步引擎系统初始化：指定多个连续地址的同步存储结构作为多个Barrier变量，同时维护一个表示多个Barrier变量完成状态的寄存器Barrier_HW_State，每个处理器在其直属的内存中申请一段空间Barrier_State作为Barrier的完成状态表示；

120.N个进程调用Barrier原语，使用所述Barrier变量执行一次Barrier操作，同时分别保存相应处理器的Barrier_State的第n位的状态到所述N个进程的本地变量Local_Barrier_State；

130.所述同步引擎在接收到对所述Barrier变量的Store指令后，根据Store的物理地址向所述Barrier变量写入值，值的大小等于N-1；

140.所述Barrier处理模块读取对应地址的同步存储结构，如果不存在这项同步存储结构，或者读取到同步存储结构中的Count等于0，则建立一项同步存储结构，其中的Count等于Store的值，如果读取到同步存储结构Count不等于0，则执行下一步骤150；

150.所述Barrier处理模块读取对应地址的同步存储结构，并把读取到的同步存储结构的Count减1；

160.判断Count值是否等于0，若是，则所有进程都已经到达了同步点，一次Barrier已经完成，把Barrier_HW_State对应的位取反，然后把Barrier_HW_State广播到多个处理器的Barrier_State的位置；否则，返回步骤150；

170.每个所述进程在发送Store指令之后，定时查询本处理器所属的Barrier_State的第n位的值，如果查询到的值等于Local_Barrier_Staten的值，则表示本进程的Barrier尚未完成，则稍后再次查询；如果查询到的状态不等于Local_Barrier_Staten，则表示Barrier已经完成，所述进程退出查询状态，同时退出Barrier原语调用。同步引擎系统初始化的步骤110，包括下列步骤：

111.指定多个连续地址的同步存储结构作为多个Barrier变量，并把指定信息写入到所述配置寄存器中；

112.在所述同步引擎内部维护一个表示多个Barrier变量完成状态的寄存器Barrier_HW_State，每一位对应一个Barrier变量的完成状态；

113.每个处理器在其直属的内存中申请一段空间Barrier_State作为Barrier的完成状态表示，每个处理器的Barrier_State都被初始化为全0，Barrier_State在对应的处理器内部的各个进程是共享的，各个进程都可以读取；

114.每个处理器把申请Barrier_State的物理地址发送到所述配置寄存器中。

为实现本发明的目的还提供一种所述多处理器的同步引擎对于Reduce原语的处理方法，所述方法，包括下列步骤：

210.同步引擎系统初始化：指定多个连续地址的同步存储结构作为多个Reduce变量，同时维护一个表示多个Reduce变量完成状态的寄存器Reduce_HW_State；每个处理器在其直属的内存中申请一段空间Reduce_State作为Reduce的完成状态表示；

220.N个进程调用Reduce原语，使用所述Reduce变量Rn执行一次Reduce操作，每个进程保存本处理器的Reduce_State的第n位的状态到本地变量Local_Reduce_State；

230.每个参与Reduce的进程把上述Reduce原语的数据结构发送到同步引擎；所述同步引擎在接收到Reduce数据结构之后，根据Reduce的物理地址向所述Reduce变量Rn量写入值，值的大小等于N-1；

240.Reduce处理模块读取对应地址的同步存储结构，如果不存在这项同步存储结构，或者读取到同步存储结构中的Count等于0，则建立一项同步存储结构，其中的Count等于N-1，并把Reduce数据结构中的源数据存储在同步存储结构中的Value中；如果读取到同步存储结构Count不等于0，则执行下一步骤250；

250.Reduce处理模块读取对应地址的同步存储结构，并把对应的Count减1，并把读取到的同步存储结构中的Value和Reduce数据结构中的源数据进行运算，把结果存放到同步存储结构中的Value中；

260.判断Count值是否等于0，若是，则说明一次Reduce完成，则把Reduce_HW_State对应的位取反，然后把Reduce_HW_State广播到n个处理器的Reduce_State的位置；否则，返回步骤250；

270.每个进程在发送Reduce数据结构之后，定时查询本处理器所属的Reduce_State的第n位的值，如果查询到的状态等于Local_Reduce_Staten，则表示本次进程的Reduce尚未完成，则稍后再次查询；如果查询到的状态不等于Local_Reduce_Staten，则表示Reduce已经完成，退出查询状态。

同步引擎系统初始化的步骤，包括下列步骤：

211.指定多个连续地址的同步存储结构{Count，P，L，Value}作为多个Reduce变量，并把指定信息写入到同步引擎的配置寄存器中；

212.在同步引擎内部维护一个表示多个Reduce变量完成状态的寄存器Reduce_HW_State，每一位对应一个Reduce变量的完成状态；

213.每个处理器在其直属的内存中申请一段空间Reduce_State作为Reduce的完成状态表示，每个处理器的Reduce_State都被初始化为全0；

214.每个处理器把申请Reduce_State的物理地址发送到同步引擎的配置寄存器中。

所述Reduce原语的数据结构为{Reduce变量地址，操作符，数据类型，进程数目-1，源数据}。

为实现本发明的目的还提供一种所述多处理器的同步引擎对于Lock原语的处理方法，所述方法，包括下列步骤：

310.每个处理器在其直属的内存中申请变量Lock_Result；把这个变量的内容清零，并把这个变量的物理地址作为Lock原语数据结构的返回物理地址；

320.所述同步引擎在接收到进程发送的Lock原语的数据结构后，根据其中的目标物理地址读取同步存储结构，如果读取不到同步存储结构，或者读取到的同步存储结构中的L位等于0，则说明此物理地址尚未被加锁，则Lock原语执行成功，转至下一步骤330；如果读取到的同步存储结构的L位等于1，则说明此物理地址已经被加锁，则放弃本次Lock的执行，把Lock原语放入相应的存储队列中，等候在此调度执行；

330.把同步存储结构中的L位置1并且保存，根据所述返回物理地址，向直属的内存的Lock_Result写入1；

340.所述进程定时查询Lock_Result，如果读取到的Lock_Result等于0，则表示尚未加锁成功，则延时后再查询；如果读取到的Lock_Result等于1，则表示加锁成功，退出Lock调用。

所述Lock原语数据结构为{返回物理地址，目标物理地址}，返回物理地址表示当加锁成功的时候，同步引擎会把成功消息存放在主存中的返回物理地址中；目标物理地址表示软件希望对哪个物理地址进行加锁。

为实现本发明的目的还提供一种所述多处理器的同步引擎对于Unlock原语的处理方法，所述方法，包括下列步骤：

进程把所述数据结构发送到所述同步引擎，并退出Unlock调用；

所述同步引擎在接收到Unlock数据结构后，根据目标地址从哈希表中读取同步数据结构，把其中的L位清零，如果同步数据结构在L位清零后等于全0，则释放这一项同步数据结构，否则仅仅把L位清零后的数据结构写回。

所述Unlock原语的数据结构为{目标地址}，数据结构中仅有的一个元素表示需要解锁的变量地址。

为实现本发明的目的还提供一种所述多处理器的同步引擎对于Put原语的处理方法，所述方法，包括下列步骤：

410.进程将Put原语的数据结构发送到所述同步引擎，并退出Put调用；

420.所述同步引擎的Put处理模块根据Put原语的数据结构中的目标地址读取相应的同步存储结构，如果不存在，则新建一项同步存储结构，如果存在则读取已存在的同步存储结构；

430.把根据Put原语的数据结构中的目标地址读取的相应的同步存储结构的P位置1，并把接收到的Put原语中的源数据存储到所述同步存储结构的Value位。

所述Put原语数据结构为{目标地址，源数据}，其中，目标地址表示Put原语中源数据被存放的物理地址；源数据表示Put原语中移动的数据内容。

为实现本发明的目的还提供一种所述多处理器的同步引擎对于Get原语的处理方法，所述方法，包括下列步骤：

510.处理器在其直属的内存空间中申请一段空间Get_Result用于存储Get返回值的数据结构，并把申请到的空间清零；

520.所述Get处理模块根据接收到的进程发送的Get原语数据结构中的目标地址，读取对应的同步存储结构，如果不存在对应的同步存储结构，则放弃Get的执行，把Get原语放回所述存储队列中，等待再次被调度执行；如果存在对应的同步存储结构，但是其中的P位为0，则放弃Get的执行，把Get原语放回到所述存储队列中，等待再次被调度执行；如果哈希表中存在对应的同步存储结构，而且其中的P位为1，则执行下一步骤530；

530.把读取到的同步存储结构中的P清零，把读取到的同步存储结构中的Value内容，根据Get原语数据结构中的返回物理地址，把返回值{1，Value}写入处理器的直属存储中；

540.如果清零后同步存储结构的Tag等于全零，则释放对应的同步存储结构项，否则把P位清零的同步存储结构写回；

550.定时查询Get_Result中数据结构的完成标识，如果查询结果为0，表示Get原语尚未执行完毕，则延时一段时间后继续查询；如果查询结果为1，则表示Get原语执行完毕，执行下一步骤560；

560.读取Get_Result中数据结构的返回数据，退出Get调用。

所述Get原语数据结构为{返回物理地址，目标物理地址}。数据结构中各个元素的含义如下：返回物理地址是当Get成功执行后，返回Get的数据以及完成标识的存放地址，Get返回值的数据结构如{返回数据，完成标识}，此返回值被连续存放在返回物理地址中；目标物理地址表示Get试图去获得的数据的物理地址。

本发明的有益效果是：本发明的同步引擎使用统一的共享存储结构，对Barrier、Lock/Unlock、Reduce、Put/Get等基本同步原语进行支持和加速，大幅度提高同步原语的执行速度，减少进程间的通信量，并简化同步原语的接口，不依赖于多处理器的Cache一致性，不依赖于处理器的特殊指令集，使得并行程序在使用同步原语时更加方便，具有使用简单，应用范围广，执行速度快的特点。

附图说明

图1是并行程序中使用Barrier同步原语实现读写次序的例子示意图；

图2是本发明的多处理器的同步引擎的结构示意图；

图3是本发明中同步存储结构的示意图；

图4是本发明中处理模块与同步存储结构进行通讯的结构示意图；

图5是本发明的同步引擎中同步存储结构对于Barrier原语的支持的步骤流程图；

图6是本发明中对于Barrier原语的支持中同步引擎系统初始化的步骤流程图；

图7是本发明的同步引擎中同步存储结构对于Reduce原语的支持的步骤流程图；

图8是本发明中对于Reduce原语的支持中同步引擎系统初始化的步骤流程图；

图9是本发明的同步引擎中同步存储结构对于Lock原语的支持的步骤流程图；

图10是本发明的同步引擎中同步存储结构对于Put原语的支持的步骤流程图；

图11是本发明的同步引擎中同步存储结构对于Get原语的支持的步骤流程图；

图12是本发明的多处理器系统的结构示意图。

具体实施方式

为了使本发明的目的、技术方案及优点更加清楚明白，以下结合附图及实施例，对本发明的一种多处理器系统及其同步引擎进行进一步详细说明。应当理解，此处所描述的具体实施例仅仅用以解释本发明，并不用于限定本发明。

本发明的一种多处理器系统及其同步引擎，改变使用软件实现同步原语的方式，使用统一的共享存储结构，通过硬件装置实现对Barrier、Lock/Unlock、Reduce、Put/Get等基本同步原语进行支持和加速，不依赖于多处理器的Cache一致性，不依赖于处理器的特殊指令集，具有使用简单，应用范围广，执行速度快的特点。

下面结合上述目标详细介绍本发明的一种多处理器的同步引擎，所述同步引擎，图2是本发明的多处理器的同步引擎的结构示意图，如图2所示，所述同步引擎，包括：

多个存储队列1，用于接收多个处理器发送的同步原语，一个队列存储来自一个处理器的所有同步原语；

处理器1到n发送的同步原语在发送到同步引擎时，分别被存储在队列1到n。

由于一个队列存储来在一个处理器的所有同步原语，而一个处理器上可能运行多个进程，因此在同步原语存储到对应的队列里时，应该同时保存进程号信息，以区别同一处理器上不同进程发送过来的同步原语。在队列的出口处使用调度模块对同一个队列里的来自不同进程的同步原语进行调度，以保证来自不同进程的同步原语不会相互阻塞。

多个调度模块2，用于在在所述多个存储队列中选定用于执行的同步原语之后，根据同步原语的类型，发送到相对应的处理模块进行处理，所述调度模块与所述存储队列一一对应；

多个处理模块3，用于接收所述调度模块发来的同步原语，执行不同功能；

所述处理模块如图2中Reduce处理模块、Barrier处理模块、Load/Store处理模块，以及Put/Get处理模块。如果有同步引擎支持更多类型的同步原语，可以在这里扩展更多的处理模块。

虚拟同步存储结构模块4，使用RAM作为存储，以及控制逻辑实现。目的在于使用少量的存储空间，通过控制逻辑把所有处理器的直属存储空间都映射为同步存储结构{Count，P，L，Value}。从而达到使用这种同步存储结构来实现各种同步原语的功能。控制逻辑实现的映射方法在下面的文字中有描述。

主存端口5，用于对各处理器的直属存储进行读和写操作，以及向处理器发起中断。

配置寄存器6，用于存储各种软件发送过来的配置信息。配置信息包括如发送中断时中断号是多少，同步引擎在向直属存储写入必要信息时，写入的物理地址是多少等。配置寄存器用寄存器实现存储，各个功能模块需要用到的配置信息都从这里读取。

在图2所示的处理模块中，使用到的数据都是由所述虚拟同步存储结构模块提供的同步存储结构{Count，P，L，Value}，这个存储结构是由所述同步引擎使用少量的片内存储虚拟出来的，并不直接占用处理器直属存储的空间。

一个存储队列1存储来自一个处理器的所有同步原语；在同步原语存储到对应的存储队列1里时，同时保存进程号信息，以区别同一处理器上不同进程发送过来的同步原语；在存储队列1的出口处使用调度模块2，根据同步原语的类型，对同一个存储队列里的来自不同进程的同步原语进行调度，以保证来自不同进程的同步原语不会相互阻塞；多个处理模块3分别根据调度模块2的调度，并使用由所述虚拟同步存储结构模块4提供的数据执行相应的同步原语，实现采用硬件装置对并行程序中的同步原语的支持和加速。

对于普通的地址空间，存储结构仅仅是存储数据的结构，如对于32位地址32’h0000_8600的地址A来说，Store(A，3556)的含义仅仅表示向地址A写入立即数3556，则3556这个值被存储在地址A的空间里。当这个Store指令被执行完毕后，使用Load(A)指令读取地址A的内容，则返回的值应该是3556。典型的处理器的直属存储，也就通常意义上的内存。但是对于这种存储结构，并不能保证Store和Load的执行次序，需要额外的方法来保证Load指令在Store指令后面执行，才能保证读出来的数据是3556。在图1中已经给出保证读写次序的一种可行方法。

在本发明中，所述同步引擎把地址空间的存储结构映射成为一种新的存储结构(同步存储结构)，图3是本发明中同步存储结构的示意图，如图3所示，使用同步存储结构不仅可以对Barrier、Lock/Unlock、Reduce等基本同步原语进行支持和加速，还能够支持一种自动维护如图1所示的读写次序而无需使用Barrier的新同步原语。这种能够自动维护读写次序的同步原语称之为Put/Get原语。Put原语代表一种写操作，Get代表一种读操作。使用本专利所述的同步引擎能够维护Put和Get的执行次序，保证Get操作读取到的内容一定是Put操作写入的内容。

所述同步存储结构是在普通的单一存储空间Value前面附加一个头部，使之构成{Count，P，L，Value}这样的同步存储结构。在同步存储结构中，{Count，P，L，}称之为同步存储的Tag。同步存储结构里面的Count和Value的位宽可以根据系统需求有不同的设定，图3标注的位宽仅仅作为一个例子。在图3中，每32位的存储空间前面有1位L，1位P，8位Count。同步存储结构里各个元素的含义如下：

Value：存储单元，用于存储数据，通用处理器可以使用常见的Store指令向里面写入内容，也可以使用常见的Load指令读取里面存储的内容。

L：Lock标志位，当Lock指令成功执行后，由同步引擎自动把这一标志位赋值为1。L内容为1表示此存储单元被加锁，则另外的对这个存储单元的加锁原语均不能被成功执行。当Unlock指令被成功执行后，由同步引擎自动把这一标志位赋值为0。L内容为0表示此单元未被加锁，之后的第一条加锁原语可以被成功执行。使用这个标志位可以支持Lock/Unlock原语。

P：Produce标志位，当Put指令成功执行后，在条件满足时由同步引擎把这一标志位赋值为1。P内容为1表示此存储单元的数据允许被Get指令获得，当Get指令成功执行后，在条件满足时，由同步引擎自动把这一标志位赋值为0。使用这个标志位可以实现Put/Get，保证读写次序。

Count：计数器，可以用于实现Barrier、Reduce，以及多种模式的Put/Get原语。计数器的位宽和同步引擎支持的最大并行进程有关，n位Count可以支持最大2ⁿ个进程。

所述同步存储结构中的Value元素是当前计算机的标准存储单元，占据真实的存储空间。而同步存储结构中的Tag是由同步引擎映射而产生的，仅仅在同步引擎内部存在，并不占用处理器的存储空间。同步存储结构的Tag不能由处理器的Load/Store指令访问，必须通过所述同步引擎支持的各种同步原语进行间接的访问。同步存储结构的地址等于映射Tag之前的Value的地址。

图4是本发明中处理模块与同步存储结构进行通讯的结构示意图，如图4所示，所述同步引擎使用少量的片内存储虚拟所述同步存储结构的虚拟方法是：使用一块片内存储作为哈希表，哈希表中每一项的结构如{关键值，Tag，Value}。当处理模块写入一项同步存储结构时，比如Put/Get模块执行Put指令，则把Put指令的地址作为关键值，使用哈希算法在哈希表内选择一行作为存储单元，把同步结构存储下来。当处理模块读取一项同步存储结构时，同样使用哈希算法找到对应于这个地址的项，哈希表输出找到的那一行的内容{Tag，Value}。如果读取过程中使用哈希算法没有找到对应的项，如Get指令先于对应的Put指令被发送到同步引擎，则说明当前指令应该暂缓执行，则指令被重新回归图2所示的存储队列中，等候下次调度执行。在同步原语被执行后，同步存储结构的Tag会根据指令的不同有所改变，如果同步存储结构的Tag的执行结果等于全0，则说明这一项同步存储结构已经被完全执行完毕，则在哈希表中释放对应的存储空间。由此，能够使用较小的片内存储空间虚拟出我们所需要的同步存储结构，而不需要改变各处理器的直属存储结构。

一般说来，存储在哈希表内的数据在很短暂的时间内就会被使用，从而同步引擎会释放其占用哈希表中的空间，因此哈希表溢出的概率是比较小的，构造哈希表所需要的片内存储空间也不会很大。一个比较相近的例子可以参考处理器的Cache，Cache的大小是远远小于内存的大小的。

当哈希表溢出的时候，则使用图2所示的主存端口向对应的处理器发送中断，由软件中断程序模拟同步引擎的过程，在处理器直属内存中构造哈希表，来处理这个过程。通过这个构造同步存储的过程，就可以在不直接占用处理器直属存储的前提下，为每个Value前面增加一个实现同步功能的Tag。从而支持Barrier、Lock/Unlock、Reduce以及Put/Get原语。

以下详细说明本发明中的同步存储结构对于Barrier、Lock/Unlock、Reduce、Put/Get等基本同步原语进行支持和加速的执行步骤。

一.以m个进程(m大于等于1)执行Barrier操作为例，图5是本发明的同步引擎中同步存储结构对于Barrier原语的支持的步骤流程图，图6是本发明中对于Barrier原语的支持中同步引擎系统初始化的步骤流程图，如图5和图6所示，包括下列步骤：

110.同步引擎系统初始化(这个步骤只需要在系统上电的时候执行一次)

111.软件指定多个连续地址的同步存储结构{Count，P，L，Value}作为多个Barrier变量，每个变量占用4Byte空间，并把指定信息写入到同步引擎的配置寄存器中；

112.在同步引擎内部维护一个表示多个Barrier变量完成状态的寄存器Barrier_HW_State，每一位对应一个Barrier变量的完成状态；

113.每个处理器在其直属的内存中申请一段空间Barrier_State作为Barrier的完成状态表示，Barrier_State的大小等于Barrier变量个数除以8，单位为Byte，每个Barrier变量的完成状态对应于Barrier_State的1bit。每个处理器的Barrier_State都被初始化为全0。Barrier_State在对应的处理器内部的各个进程是共享的，各个进程都可以读取。

假设有32个Barrier变量，则每个处理器在其直属的内存中申请4Byte的Barrier_State。Barrier变量B0的完成状态对应于Barrier_State的bit0，Barrier变量B1的完成状态对应于Barrier_State的bit1。

114.每个处理器把申请Barrier_State的物理地址发送到同步引擎的配置寄存器中，处理器1申请到的Barrier_State地址为Barrier_Mask1，处理器2申请到的Barrier_State地址为Barrier_Mask2……处理器n申请到的Barrier_State地址为Barrier_Maskn。

120.多个进程调用Barrier原语，使用某个Barrier变量Bn执行一次Barrier操作，每个进程保存本处理器的Barrier_State的第n位的状态到这个进程的本地变量Local_Barrier_State；

130.每个参与Barrier的进程使用普通的Store指令向所述Barrier变量写入某个值，此值的大小等于整个多处理器系统参与Barrier的进程个数减1。此值将被同步引擎用于计算是否所有进程都达到了同步点。

比如有m个进程(m大于等于1)使用这个Barrier变量执行一次Barrier操作。则Store的地址等于这个Barrier变量所代表的同步存储结构的地址，而Store的值等于m-1。不管多个进程的执行次序如何，Store的值都固定等于m-1，对于各个进程来说Store的值都是相同的。

140.同步引擎在接收到对Barrier变量的Store指令后，由于步骤111中软件已经把指定信息写入到配置寄存器中，根据Store的物理地址，这些Store指令都被同步引擎解释为Barrier原语。Barrier处理模块读取对应地址的同步存储结构，如果在图4所示的哈希表中不存在这项同步存储结构，或者读取到同步存储结构中的Count等于0，说明这是第一次到达同步引擎的Barrier原语，则在哈希表中建立一项同步存储结构，其中的Count等于Store的值，也就是m-1。如果读取到同步存储结构Count不等于0，则执行步骤150；

150.所述Barrier处理模块读取对应地址的同步存储结构，并把读取到的同步存储结构的Count减1；

160.如果在执行步骤140中的Barrier原语之后，Count值等于0，则说明所有进程都已经到达了同步点，一次Barrier已经完成，则把Barrier_HW_State对应的位取反，然后把Barrier_HW_State广播到多个处理器的Barrier_State的位置，同步存储结构在哈希表中不释放；否则，返回步骤150；

170.每个进程在发送Store指令之后，定时查询本处理器所属的Barrier_State的第n位的值，如果查询到的值等于步骤120的Local_Barrier_Staten，则表示本进程的Barrier尚未完成，则稍后再次查询。如果查询到的状态不等于Local_Barrier_Staten，则表示Barrier已经完成，所述进程退出查询状态，同时退出Barrier原语调用。比如查询到本处理器所属的Barrier_State的第n位的值等于0，而本进程保存的Local_Barrier_Staten等于0，则表示Barrier尚未完成；而如果查询到Local_Barrier_Staten等于1，则表示Barrier已经完成。由于只使用1bit来表示完成状态，因此它们的取值只有0和1两种。上述步骤中，除了步骤110只需要系统初始化一次，其他时候在各进程调用Barrier原语的时候，都是从步骤120开始执行，结束于步骤160。Barrier的同步原语等效于Store(Barrier变量地址，m-1)。

二.以m个进程(m大于等于1)执行Reduce操作为例，本发明的同步引擎中同步存储结构对于Reduce的支持和实现与Barrier的过程类似。同步存储结构支持的Reduce原语的数据结构为{Reduce变量地址，操作符，数据类型，进程数目-1，源数据}。数据结构中各个元素的含义如下：Reduce变量地址表示选择的被用来做Reduce运算的物理地址；操作符表示这次的Reduce的运算类型是什么，比如是“加”、“减”等；数据类型表示参与运算的源数据的类型是什么，比如是“双精度浮点”、“64位定点”等；进程数目表示有多少个进程参与这次的Reduce运算；源数据表示参与Reduce的数据。图7是本发明的同步引擎中同步存储结构对于Reduce原语的支持的步骤流程图，图8是本发明中对于Reduce原语的支持中同步引擎系统初始化的步骤流程图，如图7和图8所示，具体方法，包括下列步骤：

210.同步引擎系统初始化(这个步骤只需要在系统上电的时候执行一次)

211.软件指定多个连续地址的同步存储结构{Count，P，L，Value}作为多个Reduce变量，每个变量占用8Byte空间，并把指定信息写入到同步引擎的配置寄存器中。

212.在同步引擎内部维护一个表示多个Reduce变量完成状态的寄存器Reduce_HW_State，每一位对应一个Reduce变量的完成状态；

213.每个处理器在其直属的内存中申请一段空间Reduce_State作为Reduce的完成状态表示，Reduce_State的大小等于Reduce变量个数除以8，单位为Byte，每个Reduce变量的完成状态对应于Reduce_State的1bit。每个处理器的Reduce_State都被初始化为全0。

假设有32个Reduce变量，则每个处理器在其直属的内存中申请4Byte的Reduce_State。Reduce变量R0的完成状态对应于Reduce_State的bit0，Reduce变量R1的完成状态对应于Reduce_State的bit1。

214.每个处理器把申请Reduce_State的物理地址发送到同步引擎的配置寄存器中，处理器1申请到的Reduce_State地址为Reduce_Mask1，处理器2申请到的Reduce_State地址为Reduce_Mask2……处理器n申请到的Reduce_State地址为Reduce_Maskn。

220.某个进程调用Reduce原语，使用某个Reduce变量Rn执行一次Reduce操作，每个进程保存本处理器的Reduce_State的第n位的状态到本地变量Local_Reduce_State；

230.每个参与Reduce的进程把上述Reduce原语的数据结构发送到同步引擎，所述同步引擎在接收到Reduce数据结构之后，根据Reduce的物理地址向所述Reduce变量Rn量写入值，值的大小等于N-1；

240.同步引擎在接收到Reduce数据结构之后，Reduce处理模块读取对应地址的同步存储结构，如果在图4所示的哈希表中不存在这项同步存储结构，或者读取到同步存储结构中的Count等于0，说明这是第一次到达同步引擎的Reduce原语，则在哈希表中建立一项同步存储结构，其中的Count等于m-1，并把Reduce数据结构中的源数据存储在同步存储结构中的Value中。如果读取到同步存储结构Count不等于0，执行下一步骤250；

250.把对应的Count减1，并把读取到的同步存储结构中的Value和Reduce数据结构中的源数据进行运算，把结果存放到同步存储结构中的Value中；

260.如果在执行Reduce原语之后，Count值等于0。则说明一次Reduce完成，则把Reduce_HW_State对应的位取反，然后把Reduce_HW_State广播到n个处理器的Reduce_State的位置。同步存储结构在哈希表中不释放。否则，返回上一步骤250

270.每个进程在发送Reduce数据结构之后，定时查询本处理器所属的Reduce_State的第n位的值，如果查询到的状态等于步骤220的Local_Reduce_Staten，则表示本次进程的Reduce尚未完成，则稍后再次查询；如果查询到的状态不等于Local_Reduce_Staten，则表示Reduce已经完成，软件退出查询状态，比如查询到本处理器所属的Reduce_Staten的第n位的值等于0，而本进程保存的Local_Reduce_Staten等于0，则表示Reduce尚未完成；而如果查询到Local_Reduce_Staten等于1，则表示Reduce已经完成。由于只使用1bit来表示完成状态，因此它们的取值只有0和1两种。当查询到Reduce已经完成后，使用普通Load指令来读取相应的Reduce变量的值。

上述步骤中，除了步骤210只需要系统初始化一次，其他时候在软件调用Reduce原语的时候，都是从步骤220开始执行，结束于步骤260。

三.以m个进程(m大于等于1)执行Lock操作为例，本发明的同步引擎中同步存储结构支持的Lock原语数据结构为{返回物理地址，目标物理地址}，其中各个元素的含义如下：返回物理地址表示当加锁成功的时候，同步引擎会把成功消息存放在主存中的返回物理地址中；目标物理地址表示软件希望对哪个物理地址进行加锁。图9是本发明的同步引擎中同步存储结构对于Lock原语的支持的步骤流程图，如图9所示，具体方法，包括下列步骤：

310.每个处理器在其直属的内存中申请变量Lock_Result；把这个变量的内容清零，并把这个变量的物理地址作为Lock原语数据结构的返回物理地址；

进程把Lock原语的数据结构发送到同步引擎；

320.同步引擎在接收到Lock原语的数据结构后，根据其中的目标物理地址读取同步存储结构，如果从图5所示的哈希表中读取不到同步存储结构，或者读取到的同步存储结构中的L位等于0，则说明此物理地址尚未被加锁，则Lock原语执行成功，转至步骤330；如果读取到的同步存储结构的L位等于1，则说明此物理地址已经被加锁，则放弃本次Lock的执行，把Lock原语放入相应的存储队列中，等候在此调度执行；

330.把同步存储结构中的L位置1，并且保存至哈希表中。根据Lock数据结构中的返回物理地址，向直属的内存的Lock_Result写入1；

340.所述进程定时查询Lock_Result，如果读取到的Lock_Result等于0，则表示尚未加锁成功，则延时后再查询；如果读取到的Lock_Result等于1，则表示加锁成功，退出Lock调用。

进程每次调用Lock时，都会执行上面4个步骤。

本发明的同步引擎中同步存储结构支持的Unlock原语的数据结构为{目标地址}，数据结构中仅有的一个元素表示需要解锁的变量地址。进程只需要把所述数据结构发送到同步引擎即可退出Unlock调用。而同步引擎硬件在接收到Unlock数据结构后，根据目标地址从哈希表中读取同步数据结构，把其中的L位清零，如果同步数据结构在L位清零后等于全0，则在哈希表中释放这一项同步数据结构，否则仅仅把L位清零后的数据结构写回即可。

四.本发明的同步引擎中同步存储结构支持的Put原语数据结构为{目标地址，源数据}，其中数据结构中的各个元素的含义如下：目标地址表示Put原语中源数据被存放的物理地址；源数据表示Put原语中移动的数据内容。图10是本发明的同步引擎中同步存储结构对于Put原语的支持的步骤流程图，如图10所示，具体方法，包括下列步骤：

410.进程将Put原语的数据结构发送到同步引擎即可退出Put调用；

420.同步引擎的Put处理模块根据Put原语的数据结构中的目标地址在图4所示的哈希表中读取相应的同步存储结构，如果不存在，则新建一项同步存储结构，如果存在则读取已存在的同步存储结构。

430.把步骤420所得的同步存储结构的P位置1，以及把接收到的Put原语中的源数据存储到同步存储结构的Value位置。

五.本发明的同步引擎中同步存储结构支持的Get原语数据结构为{返回物理地址，目标物理地址}。数据结构中各个元素的含义如下：返回物理地址是当Get成功执行后，返回Get的数据以及完成标识的存放地址，Get返回值的数据结构如{返回数据，完成标识}，此返回值被连续存放在返回物理地址中；目标物理地址表示Get试图去获得的数据的物理地址。图11是本发明的同步引擎中同步存储结构对于Get原语的支持的步骤流程图，如图11所示，具体方法，包括下列步骤：

510.处理器在其直属的内存空间中申请一段空间Get_Result用于存储Get返回值的数据结构，并把申请到的空间清零；

进程发送Get原语数据结构到同步引擎；

520.Get处理模块根据接收到的Get原语数据结构中的目标地址，读取图6所示的哈希表中对应的同步存储结构。如果哈希表中不存在对应的同步存储结构，则放弃Get的执行，把Get原语放回存储队列中，等待再次被调度执行。如果哈希表中存在对应的同步存储结构，但是其中的P位为0，则放弃Get的执行，把Get原语放回到存储队列中，等待再次被调度执行；如果哈希表中存在对应的同步存储结构，而且其中的P位为1，转步骤540；

530.把读取到的同步存储结构中的P清零，把读取到的同步存储结构中的Value内容，根据Get原语数据结构中的返回物理地址，把返回值{1，Value}写入处理器的直属存储中；

540.如果清零后同步存储结构的Tag等于全零，则释放哈希表中对应的同步存储结构项，否则把P位清零的同步存储结构写回。

虽然Get把P位清零了。但是对应的这一行同步存储结构还可能被用来做其他用途，比如其中的L位是置1的，表示这一行同步存储结构还被加锁了。那么就不能释放这行同步存储。只有Tag等于全零了，才表示这行数据无用了。

550.定时查询Get_Result中数据结构的完成标识，如果查询结果为0，表示Get原语尚未执行完毕，则延时一段时间后继续查询；如果查询结果为1，则表示Get原语执行完毕，执行步骤560。

560.读取Get_Result中数据结构的返回数据，退出Get调用。

相应于本发明的一种多处理器的同步引擎，还提供一种多处理器系统，图12是本发明的多处理器系统的结构示意图，如图12所示，所述系统7，包括：多个处理器71和一个处理芯片72，其中：

所述处理芯片72，包括：

多个设备端口721，用于和所述多个处理器的高速互联，每个处理器和一个设备端口连接；

所述同步引擎，用于与芯片内部的多个设备端口互联。

图12显示了同步引擎在n个处理器环境下的拓扑结构。在一个芯片内实现n个设备端口用于和处理器的高速互联，每个处理器和一个设备端口连接。在设备发现过程中，每个处理器通过标准设备搜索流程都可以搜索到与之互联的设备端口，并分配设备端口申请的各种资源，主要是地址空间资源。芯片内部的多个设备端口都和同步引擎互联，同步引擎所需要的资源都由设备端口代为向处理器之上的操作系统申请。操作系统分配资源给对应的设备端口，实际上是把资源分配给同步引擎。同时，同步引擎也把自身的资源通过设备端口映射到对应的操作系统上面。由于同步引擎通过n个设备端口把自身映射到n个处理器之上的操作系统中，因此在n个处理器上的软件都可以通过映射关系，像操作独占资源那样去操作同步引擎，因此同步引擎实际上被n个处理器共享。

本发明的有益效果是：本发明的同步引擎使用统一的共享存储结构，对Barrier、Lock/Unlock、Reduce、Put/Get等基本同步原语进行支持和加速，大幅度提高同步原语的执行速度，减少进程间的通信量，并简化同步原语的接口，不依赖于多处理器的Cache一致性，不依赖于处理器的特殊指令集，使得并行程序在使用同步原语时更加方便，具有使用简单，应用范围广，执行速度快的特点。

通过结合附图对本发明具体实施例的描述，本发明的其它方面及特征对本领域的技术人员而言是显而易见的。

以上对本发明的具体实施例进行了描述和说明，这些实施例应被认为其只是示例性的，并不用于对本发明进行限制，本发明应根据所附的权利要求进行解释。

Claims (19)

1.一种多处理器的同步引擎装置，其特征在于，所述同步引擎装置，包括：

多个存储队列，用于接收多个处理器发送的同步原语，一个队列存储来自一个处理器的所有同步原语；

多个调度模块，用于在所述多个存储队列中选定用于执行的同步原语之后，根据同步原语的类型，发送到相对应的处理模块进行处理，所述调度模块与所述存储队列一一对应；

多个处理模块，用于接收所述调度模块发来的同步原语，执行不同功能；

虚拟同步存储结构模块，使用少量的存储空间，通过控制逻辑把所有处理器的直属存储空间都映射为同步存储结构来实现各种同步原语的功能；

主存端口，用于与所述虚拟同步存储结构模块进行通讯，对各处理器的直属存储进行读和写，以及向所述处理器发起中断；

配置寄存器，用于存储所述处理模块需要用到的各种配置信息；

所述处理模块，包括：Reduce处理模块、Barrier处理模块、Load/Store处理模块，以及Put/Get处理模块；

所述同步存储结构是{Count，P，L，Value}，{Count，P，L，}称为同步存储的Tag，Count和Value的位宽可以根据系统需求进行不同的设定；Value：存储单元，用于存储数据，L：Lock标志位，用于支持Lock/Unlock原语；P：Produce标志位，用于实现Put/Get原语，Count：计数器，用于实现Barrier原语、Reduce原语，以及多种模式的Put/Get原语；计数器的位宽和同步引擎装置支持的最大并行进程有关，n位Count可以支持最大2ⁿ个进程。

2.根据权利要求1所述的多处理器的同步引擎装置，其特征在于，所述多个存储队列，在同步原语存储到对应的存储队列里时，将同时保存进程号信息，以区别同一处理器上不同进程发送过来的同步原语。

3.根据权利要求1所述的多处理器的同步引擎装置，其特征在于，所述同步引擎装置中的处理模块，能够根据同步引擎装置支持的同步原语的类型进行扩展。

4.根据权利要求1所述的多处理器的同步引擎装置，其特征在于，所述同步存储结构是使用少量的片内存储虚拟出来的，并不直接占用处理器直属存储的空间。

5.根据权利要求4所述的多处理器的同步引擎装置，其特征在于，所述同步存储结构的虚拟方法是：使用一块片内存储作为哈希表，哈希表中每一项的结构为{关键值，Tag，Value}，当处理模块写入一项同步存储结构时，所述处理模块执行指令，把指令的地址作为关键值，使用哈希算法在哈希表内选择一行作为存储单元，把同步结构存储下来；当处理模块读取一项同步存储结构时，同样使用哈希算法找到对应于这个地址的项，哈希表输出找到的那一行的内容{Tag，Value}；如果读取过程中使用哈希算法没有找到对应的项，则说明当前指令应该暂缓执行，则指令被重新回归相应的存储队列中，等候下次调度执行；在同步原语被执行后，如果同步存储结构的Tag的执行结果等于全0，则说明这一项同步存储结构已经被完全执行完毕，则在哈希表中释放对应的存储空间；当所述哈希表溢出的时候，则使用所述主存端口向对应的处理器发送中断，在所述处理器直属内存中构造哈希表，来存储所述同步存储结构。

6.一种采用权利要求1-5中的任一项所述的多处理器的同步引擎装置的多处理器系统，其特征在于，所述系统，包括：多个处理器和一个处理芯片，其中：

所述处理芯片，包括：

多个设备端口，用于和所述多个处理器高速互联，每个处理器和一个设备端口连接；

所述同步引擎装置，其中，所述存储队列与所述多个设备端口互联；

在设备发现过程中，每个处理器通过标准设备搜索流程搜索到与之互联的设备端口，并分配设备端口申请的各种资源；所述同步引擎装置把自身的资源通过设备端口映射到对应的处理器的操作系统中，在多个处理器上的软件通过映射关系操作所述同步引擎装置，所述同步引擎装置被多个处理器共享。

7.根据权利要求1所述的多处理器的同步引擎装置对于Barrier原语的处理方法，其特征在于，所述方法，包括下列步骤：

110.同步引擎装置系统初始化：指定多个连续地址的同步存储结构作为多个Barrier变量，同时维护一个表示多个Barrier变量完成状态的寄存器Barrier_HW_State，每个处理器在其直属的内存中申请一段空间Barrier_State作为Barrier的完成状态表示；

120.N个进程调用Barrier原语，使用所述Barrier变量执行一次Barrier操作，同时分别保存相应处理器的Barrier_State的第n位的状态到所述N个进程的本地变量Local_Barrier_State；

130.所述同步引擎装置在接收到对所述Barrier变量的Store指令后，根据Store的物理地址向所述Barrier变量写入值，值的大小等于N-1；

140.Barrier处理模块读取对应地址的同步存储结构，如果不存在这项同步存储结构，或者读取到同步存储结构中的Count等于0，则建立一项同步存储结构，其中的Count等于Store的值，如果读取到同步存储结构Count不等于0，则执行下一步骤150；

150.所述Barrier处理模块读取对应地址的同步存储结构，并把读取到的同步存储结构的Count减1；

160.判断Count值是否等于0，若是，则所有进程都已经到达了同步点，一次Barrier已经完成，把Barrier_HW_State对应的位取反，然后把Barrier_HW_State广播到多个处理器的Barrier_State的位置；否则，返回步骤150；

170.每个所述进程在发送Store指令之后，定时查询本处理器所属的Barrier_State的第n位的值，如果查询到的值等于Local_Barrier_Staten的值，则表示本进程的Barrier尚未完成，则稍后再次查询；如果查询到的状态不等于Local_Barrier_Staten，则表示Barrier已经完成，所述进程退出查询状态，同时退出Barrier原语调用。

8.根据权利要求7所述的处理方法，其特征在于，同步引擎装置系统初始化的步骤110，包括下列步骤：

111.指定多个连续地址的同步存储结构作为多个Barrier变量，并把指定信息写入到所述配置寄存器中；

112.在所述同步引擎装置内部维护一个表示多个Barrier变量完成状态的寄存器Barrier_HW_State，每一位对应一个Barrier变量的完成状态；

113.每个处理器在其直属的内存中申请一段空间Barrier_State作为Barrier的完成状态表示，每个处理器的Barrier_State都被初始化为全0，Barrier_State在对应的处理器内部的各个进程是共享的，各个进程都可以读取；

114.每个处理器把申请Barrier_State的物理地址发送到所述配置寄存器中。

9.根据权利要求1所述的多处理器的同步引擎装置对于Reduce原语的处理方法，其特征在于，所述方法，包括下列步骤：

210.同步引擎装置系统初始化：指定多个连续地址的同步存储结构作为多个Reduce变量，同时维护一个表示多个Reduce变量完成状态的寄存器Reduce_HW_State；每个处理器在其直属的内存中申请一段空间Reduce_State作为Reduce的完成状态表示；

220.N个进程调用Reduce原语，使用所述Reduce变量Rn执行一次Reduce操作，每个进程保存本处理器的Reduce_State的第n位的状态到本地变量Local_Reduce_State；

230.每个参与Reduce的进程把上述Reduce原语的数据结构发送到同步引擎装置；所述同步引擎装置在接收到Reduce数据结构之后，根据Reduce的物理地址向所述Reduce变量Rn写入值，值的大小等于N-1；

240.Reduce处理模块读取对应地址的同步存储结构，如果不存在这项同步存储结构，或者读取到同步存储结构中的Count等于0，则建立一项同步存储结构，其中的Count等于N-1，并把Reduce数据结构中的源数据存储在同步存储结构中的Value中；如果读取到同步存储结构Count不等于0，则执行下一步骤250；

250.Reduce处理模块读取对应地址的同步存储结构，并把对应的Count减1，并把读取到的同步存储结构中的Value和Reduce数据结构中的源数据进行运算，把结果存放到同步存储结构中的Value中；

260.判断Count值是否等于0，若是，则说明一次Reduce完成，则把Reduce_HW_State对应的位取反，然后把Reduce_HW_State广播到n个处理器的Reduce_State的位置；否则，返回步骤250；

270.每个进程在发送Reduce数据结构之后，定时查询本处理器所属的Reduce_State的第n位的值，如果查询到的状态等于Local_Reduce_Staten，则表示本次进程的Reduce尚未完成，则稍后再次查询；如果查询到的状态不等于Local_Reduce_Staten，则表示Reduce已经完成，退出查询状态。

10.根据权利要求9所述的处理方法，其特征在于，同步引擎装置系统初始化的步骤，包括下列步骤：

211.指定多个连续地址的同步存储结构{Count，P，L，Value}作为多个Reduce变量，并把指定信息写入到同步引擎装置的配置寄存器中；

212.在同步引擎装置内部维护一个表示多个Reduce变量完成状态的寄存器Reduce_HW_State，每一位对应一个Reduce变量的完成状态；

213.每个处理器在其直属的内存中申请一段空间Reduce_State作为Reduce的完成状态表示，每个处理器的Reduce_State都被初始化为全0；

214.每个处理器把申请Reduce_State的物理地址发送到同步引擎装置的配置寄存器中。

11.根据权利要求9所述的处理方法，其特征在于，所述Reduce原语的数据结构为{Reduce变量地址，操作符，数据类型，进程数目-1，源数据}。

12.根据权利要求1所述的多处理器的同步引擎装置对于Lock原语的处理方法，其特征在于，所述方法，包括下列步骤：

310.每个处理器在其直属的内存中申请变量Lock_Result；把这个变量的内容清零，并把这个变量的物理地址作为Lock原语数据结构的返回物理地址；

320.所述同步引擎装置在接收到进程发送的Lock原语的数据结构后，根据其中的目标物理地址读取同步存储结构，如果读取不到同步存储结构，或者读取到的同步存储结构中的L位等于0，则说明此物理地址尚未被加锁，则Lock原语执行成功，转至下一步骤330；如果读取到的同步存储结构的L位等于1，则说明此物理地址已经被加锁，则放弃本次Lock的执行，把Lock原语放入相应的存储队列中，等候在此调度执行；

330.把同步存储结构中的L位置1并且保存，根据所述返回物理地址，向直属的内存的Lock_Result写入1；

340.所述进程定时查询Lock_Result，如果读取到的Lock_Result等于0，则表示尚未加锁成功，则延时后再查询；如果读取到的Lock_Result等于1，则表示加锁成功，退出Lock调用。

13.根据权利要求12所述的处理方法，其特征在于，所述Lock原语数据结构为{返回物理地址，目标物理地址}，返回物理地址表示当加锁成功的时候，同步引擎装置会把成功消息存放在主存中的返回物理地址中；目标物理地址表示软件希望对哪个物理地址进行加锁。

14.根据权利要求1所述的多处理器的同步引擎装置对于Unlock原语的处理方法，其特征在于，所述方法，包括下列步骤：

进程把Unlock原语的数据结构发送到所述同步引擎装置，并退出Unlock调用；

所述同步引擎装置在接收到Unlock原语的数据结构后，根据目标地址从哈希表中读取同步数据结构，把其中的L位清零，如果同步数据结构在L位清零后等于全0，则释放这一项同步数据结构，否则仅仅把L位清零后的数据结构写回。

15.根据权利要求14所述的处理方法，其特征在于，所述Unlock原语的数据结构为{目标地址}，数据结构中仅有的一个元素表示需要解锁的变量地址。

16.根据权利要求1所述的多处理器的同步引擎装置对于Put原语的处理方法，其特征在于，所述方法，包括下列步骤：

410.进程将Put原语的数据结构发送到所述同步引擎装置，并退出Put调用；

420.所述同步引擎装置的Put/Get处理模块根据Put原语的数据结构中的目标地址读取相应的同步存储结构，如果不存在，则新建一项同步存储结构，如果存在则读取已存在的同步存储结构；

430.把根据Put原语的数据结构中的目标地址读取的相应的同步存储结构的P位置1，并把接收到的Put原语中的源数据存储到所述同步存储结构的Value位。

17.根据权利要求16所述的处理方法，其特征在于，所述Put原语数据结构为{目标地址，源数据}，其中，目标地址表示Put原语中源数据被存放的物理地址；源数据表示Put原语中移动的数据内容。

18.根据权利要求1所述的多处理器的同步引擎装置对于Get原语的处理方法，其特征在于，所述方法，包括下列步骤：

510.处理器在其直属的内存空间中申请一段空间Get_Result用于存储Get返回值的数据结构，并把申请到的空间清零；

520.所述Put/Get处理模块根据接收到的进程发送的Get原语数据结构中的目标地址，读取对应的同步存储结构，如果不存在对应的同步存储结构，则放弃Get的执行，把Get原语放回所述存储队列中，等待再次被调度执行；如果存在对应的同步存储结构，但是其中的P位为0，则放弃Get的执行，把Get原语放回到所述存储队列中，等待再次被调度执行；如果哈希表中存在对应的同步存储结构，而且其中的P位为1，则执行下一步骤530；

530.把读取到的同步存储结构中的P清零，读取同步存储结构中的Value内容，根据Get原语数据结构中的返回物理地址，把返回值{1，Value}写入处理器的直属存储中，其中返回值{1，Value}中的1为完成标识，代表本次读取完成；

540.如果清零后同步存储结构的Tag等于全零，则释放对应的同步存储结构项，否则把P位清零的同步存储结构写回；

550.定时查询Get_Result中数据结构的完成标识，如果查询结果为0，表示Get原语尚未执行完毕，则延时一段时间后继续查询；如果查询结果为1，则表示Get原语执行完毕，执行下一步骤560；

560.读取Get_Result中数据结构的返回数据，退出Get调用。

19.根据权利要求18所述的处理方法，其特征在于，所述Get原语数据结构为{返回物理地址，目标物理地址}；数据结构中各个元素的含义如下：返回物理地址是当Get成功执行后，返回Get的数据以及完成标识的存放地址，Get返回值的数据结构如{返回数据，完成标识}，此返回值被连续存放在返回物理地址中；目标物理地址表示Get试图去获得的数据的物理地址。

Images