CN113227975B - 一种同步方法及装置 - Google Patents

Abstract

本申请实施例公开了一种同步方法及装置，涉及人工智能领域，改善了现有技术不支持AI服务器间同步等问题。具体方案为：第一处理器为第一同步事件创建第一同步对象；第一同步对象中包括第一同步寄存器的标识，第一同步寄存器的值包括第一数值或第二数值，第一数值用于指示第一同步事件未发生，第二数值用于指示第一同步事件已经发生；第一处理器包括第一中央处理器CPU；第二处理器基于第一同步寄存器的值，确定第一同步事件是否发生；第二处理器包括第一神经网络处理器NPU。

Description

一种同步方法及装置

技术领域

本申请实施例涉及人工智能领域，尤其涉及一种同步方法及装置。

背景技术

人工智能(artificial intelligence，AI)场景一般需要海量的计算算力，由于单块AI加速器(例如，神经网络处理器(neural-network process unit，NPU))，或者单个AI服务器(例如，包括多块AI加速器的AI服务器)的计算算力有限，通常不能满足AI场景的算力需求，因此需要多个AI服务器组成集群来提供AI场景所需的算力。当多个AI服务器组成集群进行AI训练时，为了减少一个AI加速器内、一个AI服务器内的不同AI加速器间，以及AI服务器间的同步传输及同步等待时间，提供一种合理的同步机制是非常有必要的。

发明内容

本申请实施例提供一种同步方法及装置，能够实现一个AI加速器内、一个AI服务器内的不同AI加速器间，以及AI服务器间的同步。

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

本申请实施例的第一方面，提供一种方法同步方法，所述方法包括：第一处理器为第一同步事件创建第一同步对象；该第一同步对象中包括第一同步寄存器的标识，该第一同步寄存器的值包括第一数值或第二数值，第一数值用于指示该第一同步事件未发生，第二数值用于指示该第一同步事件已经发生；第二处理器基于该第一同步寄存器的值，确定第一同步事件是否发生。

可选的，上述第一处理器包括第一中央处理器CPU，第二处理器包括第一神经网络处理器NPU。例如，第一处理器可以为AI服务器内的CPU，第二处理器可以为AI服务器内的AI加速器。该CPU和AI加速器位于同一个AI服务器内。该第二处理器为等待第一同步事件发生的AI加速器。

可选的，第一同步事件可以发生在一个NPU内，也可以发生在一个AI服务器内的不同NPU之间，还可以发生在不同AI服务器间。

基于本方案，通过为同步事件创建同步对象，而且每个同步对象与一个同步寄存器相对应，AI加速器可以基于该同步寄存器的值，确定该同步寄存器对应的同步事件是否发生，从而能够实现一个AI加速器内、一个AI服务器内的不同AI加速器间，以及AI服务器间的同步。

结合第一方面，在一种可能的实现方式中，上述第一处理器为第一同步事件创建第一同步对象，包括：第一处理器通过调用第一应用程序接口API，在上述第二处理器包括的多个同步寄存器中为第一同步事件分配第一同步寄存器，并在第一同步对象中保存第一同步寄存器的标识。

可选的，第一API用于为同步事件创建同步对象。该第一API可以为NotifyCreat(deviceID，notify)，其中，输入deviceID为AI加速器的ID，输出notify为同步对象，该NotifyCreat接口用于创建同步对象。该deviceID为等待同步事件发生的AI加速器的ID。

基于本方案，通过在AI加速器中设置一组同步寄存器，从而在需要进行同步时，CPU可以在等待同步事件发生的AI加速器包括的多个同步寄存器中为第一同步事件分配第一同步寄存器，从而使得第一同步寄存器的值一旦发生变化，该AI加速器可以立刻检查到第一同步寄存器的取值修改，能够较快的确定第一同步事件是否发生，实现一个AI加速器内、一个AI服务器内的不同AI加速器间，以及不同AI服务器间的同步。而且本申请实施例的方案提供的API接口较简单，同步开销较小，因此能够提升AI训练的效率。

结合第一方面和上述可能的实现方式，在另一种可能的实现方式中，上述方法还包括：上述第一处理器通过调用第二API，向上述第二处理器发送第一同步事件对应的等待任务；该第一同步事件对应的等待任务用于等待第一同步事件发生，第一同步事件对应的等待任务包括第一队列标识，以及第一同步寄存器的标识；该第一队列标识为等待任务所在的队列的标识；第二处理器接收该第一同步事件对应的等待任务。

基于本方案，CPU可以通过简单的API向AI加速器下发用于等待同步事件发生的等待任务，并在该等待任务中携带同步寄存器的标识，从而使得AI加速器根据该同步寄存器的不同取值可以确定同步事件是否发生，因此能够实现一个AI加速器内、一个AI服务器内的不同AI加速器间，以及AI服务器间的同步。

可选的，第二API用于下发同步事件对应的等待任务。该第二API可以为NotifyWait(notify，stream)接口，该接口用于在stream等待同步对象对应的同步事件发生。

结合第一方面和上述可能的实现方式，在另一种可能的实现方式中，上述第二处理器基于上述第一同步寄存器的值，确定第一同步事件是否发生，包括：在第一同步寄存器的值为第一数值的情况下，第二处理器确定第一同步事件未发生，第二处理器继续等待该第一同步事件发生，直至第一同步寄存器的值为第二数值，第二处理器确定该第一同步事件已经发生，第二处理器将第一同步寄存器的值重置为第一数值。

基于本方案，AI加速器可以在第一同步事件未发生的情况下，一直等待第一同步事件发生，直至第一同步事件已经发生，再将第一同步寄存器的重置为第一数值，并继续执行接下来的任务。因此能够实现一个AI加速器内，一个AI服务器内的不同AI加速器间，以及不同AI服务器间的同步。

可以理解的，当第一同步事件发生时，第一寄存器的值从第一数值变为第二数值，由于第一同步寄存器为第二处理器中的同步寄存器，因此第二处理器的控制器可以立刻检查到第一同步寄存器的取值修改，第二处理器确定第一同步事件已经发生，第二处理器将第一同步寄存器的值重置为第一数值，以便第一同步寄存器可以继续进行同步操作。

结合第一方面和上述可能的实现方式，在另一种可能的实现方式中，上述第二处理器基于第一同步寄存器的值，确定第一同步事件是否发生，还包括：在第一同步寄存器的值为第二数值的情况下，第二处理器确定第一同步事件已经发生，第二处理器将第一同步寄存器的值重置为第一数值。

基于本方案，当第二处理器检查到第一同步寄存器的值为第二数值时，第二处理器确定第一同步事件已经发生，第二处理器将第一同步寄存器的值重置为第一数值。然后第二处理器可以继续执行后续的任务，从而能够确保正确同步，实现一个AI加速器内，一个AI服务器内的不同AI加速器间，以及不同AI服务器间的同步。

结合第一方面和上述可能的实现方式，在另一种可能的实现方式中，上述方法还包括：第一处理器通过调用第三API，向第二处理器发送第一同步事件对应的记录任务；该第一同步事件对应的记录任务用于指示上述第一同步事件已经发生，第一同步事件对应的记录任务中包括第二队列标识，以及第一同步寄存器的标识，第二队列标识为第一同步事件对应的记录任务所在的队列的标识；第二处理器接收第一同步事件对应的记录任务，并基于第一同步寄存器的标识，将第一同步寄存器的值重置为第二数值。

基于本方案，CPU可以通过简单的API向AI加速器(第二处理器)下发用于指示同步事件已经发生的记录任务，并在该等待任务中携带同步寄存器的标识，使得AI加速器根据该同步寄存器的标识写入第二数值，从而同步寄存器的值可以与第一同步事件的发生状态相对应。由于第一同步寄存器为第二处理器中的同步寄存器，因此第二处理器的控制器可以立刻检查到第一同步寄存器的取值修改，第二处理器确定第一同步事件已经发生，第二处理器可以继续执行后续的任务，从而确保第二处理器内能够正确同步。

可选的，第三API用于下发同步事件对应的记录任务。该第三API可以为NotifyRecord(notify，stream)接口，该接口用于在stream设置同步对象对应的同步事件发生。

可选的，当第一同步事件发生在一个AI加速器内时，上述第二处理器既执行Wait任务，又执行Record任务。第二处理器既执行Wait任务，又执行Record任务时，Wait任务和Record任务可以分别为两个Stream中的任务。

可选的，当第一同步事件发生在一个AI服务器内的两个AI加速器之间时，第二处理器执行Wait任务，第三处理器执行Record任务。

结合第一方面和上述可能的实现方式，在另一种可能的实现方式中，上述方法还包括：上述第一处理器通过调用第三API，向第三处理器发送第一同步事件对应的记录任务；第一同步事件对应的记录任务用于指示第一同步事件已经发生，第一同步事件对应的记录任务中包括第二队列标识，以及第一同步寄存器的标识，第二队列标识为所述第一同步事件对应的记录任务所在的队列的标识；该第三处理器包括第二NPU；第三处理器接收该第一同步事件对应的记录任务，并基于第一同步寄存器的标识，将第一同步寄存器的值重置为所述第二数值。

可选的，该第三处理器与上述第二处理器可以为一个AI服务器内的不同NPU。

基于本方案，CPU可以通过简单的API向AI加速器(第三处理器)下发用于指示同步事件已经发生的记录任务，并在该等待任务中携带同步寄存器的标识，使得AI加速器根据该同步寄存器的标识写入第二数值，从而同步寄存器的值可以与第一同步事件的发生状态相对应。由于第一同步寄存器为第二处理器中的同步寄存器，因此第二处理器的控制器可以立刻检查到第一同步寄存器的取值修改，第二处理器确定第一同步事件已经发生，第二处理器可以继续执行后续的任务，从而确保AI服务器内的第二处理器和第三处理器件间能够正确同步。

可以理解的，本方案提供的同步方法中，同步开销为AI加速器的控制器通过总线写寄存器的开销，该同步开销较小。例如，采用本方案提供的同步方法，对于一个NPU内的同步而言，同步开销小于50ns，对于一个AI服务器内的不同NPU间的同步，同步开销小于1us。而且本方案提供了简单的API接口，和通用OS的semaphore接口类似，可以大大方便开发者使用AI加速器。

结合第一方面和上述可能的实现方式，在另一种可能的实现方式中，若上述第一同步事件为进程间的同步事件，上述方法还包括：上述第一处理器通过调用第一应用程序的第四API，将第一同步对象的名称设置为预设名称；第一处理器通过调用第二应用程序的第五API，获取预设名称对应的第一同步寄存器的标识。

基于本方案，如果同步事件为进程间的同步事件，通过预先设置该同步对象的全局名称，从而能够将不同进程间的同步对象与同一个同步寄存器对应，再通过调用第二API和第三API，能够实现进程间的同步。

可选的，第四API用于设置同步对象的全局名称。该第四API可以为IpcSetNotifyName(notify，name)，用于设置同步对象notify的全局名称。第五API用于获取预设名称对应的寄存器的标识。该第五API可以为IpcOpenNotify(notify，name)，用于根据同步对象notify的全局名称name，打开同步对象。

结合第一方面和上述可能的实现方式，在另一种可能的实现方式中，上述第一同步事件为上述第一应用程序和上述第二应用程序之间的同步事件，上述预设名称为该第一应用程序和该第二应用程序预先约定的名称。

基于本方案，在同步事件为进程间同步的情况下，通过不同应用程序预先设置该同步对象的全局名称，从而能够将不同进程间的同步对象与同一个同步寄存器对应，进而实现进程间的同步。

可选的，无论第一同步事件是一个APP的同步事件，还是多个APP之间的同步事件，该第一同步事件可以发生在一个AI加速器内，也可以发生在一个AI服务器内的不同AI加速器间。

结合第一方面和上述可能的实现方式，在另一种可能的实现方式中，上述方法还包括：上述第一处理器通过调用第六API，获取第二同步寄存器的虚拟地址；该第二同步寄存器为第二同步事件对应的寄存器，该第二同步寄存器的不同值用于指示第二同步事件是否发生；第一处理器向第四处理器发送该第二同步寄存器的虚拟地址；该第一处理器和第四处理器为不同AI服务器中的处理器，该第四处理器包括第二CPU。

可选的，第一处理器和第四处理器可以分别为两个AI加速器中的CPU。

基于本方案，通过将同步寄存器的物理地址转换为虚拟地址，从而通过在虚拟地址对应的同步寄存器中写入数值，指示同步事件已经发生，从而能够实现AI加速器间的同步。而且本方案在进行AI服务器间的同步时，同步开销仅是网络通讯的时间开销，没有其它额外开销，因此同步开销较小。而且本申请实施例提供了简单的API接口，和通用OS的semaphore接口类似，大大方便开发者使用AI加速器。

可选的，第六API用于获取同步对象对应的寄存器的虚拟地址。该第六API可以为NotifyGetAddr(notify，addr)，其中输入为同步对象notify，输出为同步对象notify对应的同步寄存器的虚拟地址。

结合第一方面和上述可能的实现方式，在另一种可能的实现方式中，上述方法还包括：第一处理器通过调用第七API，解除上述第一同步寄存器与上述第一同步事件的对应关系，并将上述第一同步寄存器的值重置为上述第一数值；该第七API用于释放第一同步寄存器。

基于本方案，通过解除第一同步寄存器与第一同步事件的对应关系，可以将该第一同步寄存器回收，从而在后续需要进行同步时，可以将该同步寄存器分配给其他同步对象，提升了同步寄存器的利用率。

可选的，第七API用于释放第一同步寄存器。第七API可以为NotifyDestroy(notify)，该接口可以用于销毁同步对象notify，释放同步对象对应的同步寄存器。

结合第一方面和上述可能的实现方式，在另一种可能的实现方式中，上述第一同步寄存器的物理地址采用全局编址方式编址。

基于本方案，通过将同步寄存器采用全局编址方式编址，从而每个AI加速器的控制器，可以获知AI服务器内其他AI加速器中的同步寄存器的物理地址，同时也可以通过物理地址，访问其他AI加速器的同步寄存器，可以实现AI加速器内及AI加速器间的同步。

本申请实施例的第二方面，提供一种同步方法，该方法包括：第四处理器接收来自第一处理器的第二同步寄存器的虚拟地址；该第二同步寄存器为第二同步事件对应的寄存器，该第二同步寄存器的值包括第一数值或第二数值，第一数值用于指示第二同步事件未发生，第二数值用于指示第二同步事件已经发生；第一处理器和第四处理器为不同AI服务器中的处理器，第一处理器包括第一中央处理器CPU，第四处理器包括第二CPU；第四处理器通过向第五处理器发送第二同步事件对应的远程直接内存存取RDMA任务；第二同步事件对应的RDMA任务用于指示第二同步事件已经发生，第二同步事件对应的RDMA任务中包括所述第二同步寄存器的虚拟地址；第五处理器接收第二同步事件对应的RDMA任务，并基于第二同步寄存器的虚拟地址，通过RDMA装置将第二同步寄存器的值重置为所述第二数值，第五处理器包括第三NPU。

可选的，第一处理器和第四处理器可以分别为不同AI加速器中的CPU。第四处理器和第五处理器为同一个AI加速器内不同处理器，例如，第四处理器为AI加速器内的CPU，第五处理器为该AI加速器内的NPU。

基于本方案，一个AI服务器内的AI加速器通过获取同步寄存器的虚拟地址，从而该AI加速器可以在同步事件发生时，通过RDMA装置在虚拟地址对应的同步寄存器中写入数值，指示同步事件已经发生，使得另一个AI服务器内的AI加速器可以立刻检查到该同步寄存器的数值发生变化，从而确定该同步事件发生，能够实现不同AI加速器间的同步。

可选的，第四处理器可以通过调用第八应用程序接口API，向第五处理器发送第二同步事件对应的RDMA任务。该第八API用于下发同步事件对应的RDMA任务。该第八API可以为RDMAsend(addr，1)，用于指示向虚拟地址addr写入第二数值1。

本申请实施例的第三方面，提供一种同步方法，该方法包括：第四处理器接收来自第一处理器的第二同步寄存器的虚拟地址，该第二同步寄存器为第二同步事件对应的寄存器，第二同步寄存器的值包括第一数值或第二数值，第一数值用于指示第二同步事件未发生，第二数值用于指示第二同步事件已经发生；第一处理器和第四处理器为不同AI服务器中的处理器；第一处理器包括第一中央处理器CPU，第四处理器包括第二CPU；第四处理器基于该第二同步寄存器的虚拟地址，通过远程直接内存存取RDMA装置将第二同步寄存器的值重置为第二数值。

可选的，第一处理器和第四处理器可以分别为两个AI加速器中的CPU。

基于本方案，一个AI服务器内的CPU通过获取同步寄存器的虚拟地址，从而该CPU可以在同步事件发生时，通过RDMA在虚拟地址对应的同步寄存器中写入数值，指示同步事件已经发生，使得另一个AI服务器内的AI加速器可以立刻检查到该同步寄存器的数值发生变化，从而确定该同步事件发生，能够实现不同AI加速器间的同步。

本申请实施例的第四方面，提供一种同步装置，该同步装置包括第二处理器，该第二处理器包括多个同步寄存器，每个同步寄存器用于与一个同步事件相对应，每个同步寄存器的值包括第一数值或第二数值，该第一数值用于指示同步寄存器对应的同步事件未发生，该第二数值用于指示同步寄存器对应的同步事件已经发生；该第二处理器包括第一神经网络处理器NPU。

结合第四方面，在一种可能的实现方式中，上述同步装置还包括第一处理器；该第一处理器，用于为第一同步事件创建第一同步对象；该第一同步对象中包括第一同步寄存器的标识；该第一同步寄存器的不同值用于指示第一同步事件是否发生；第二处理器，用于基于该第一同步寄存器的值，确定第一同步事件是否发生；第一处理器包括第一中央处理器CPU。

结合第四方面和上述可能的实现方式，在另一种可能的实现方式中，上述第一处理器，具体用于通过调用第一应用程序接口API，在上述第二处理器包括的多个同步寄存器中为第一同步事件分配第一同步寄存器，并在第一同步对象中保存第一同步寄存器的标识。

结合第四方面和上述可能的实现方式，在另一种可能的实现方式中，上述第一处理器，还用于通过调用第二API，向上述第二处理器发送第一同步事件对应的等待任务；第一同步事件对应的等待任务用于等待上述第一同步事件发生，该第一同步事件对应的等待任务包括第一队列标识，以及上述第一同步寄存器的标识；该第一队列标识为上述等待任务所在的队列的标识；第二处理器，还用于接收该第一同步事件对应的等待任务。

结合第四方面和上述可能的实现方式，在另一种可能的实现方式中，上述第二处理器，具体用于在上述第一同步寄存器的值为第一数值的情况下，确定第一同步事件未发生，第二处理器继续等待该第一同步事件发生，直至第一同步寄存器的值为第二数值，第二处理器确定该第一同步事件已经发生，将第一同步寄存器的值重置为第一数值。

结合第四方面和上述可能的实现方式，在另一种可能的实现方式中，上述第二处理器，具体还用于在上述第一同步寄存器的值为上述第二数值的情况下，确定上述第一同步事件已经发生，将上述第一同步寄存器的值重置为上述第一数值。

结合第四方面和上述可能的实现方式，在另一种可能的实现方式中，上述第一处理器，还用于通过调用第三API，向上述第二处理器发送第一同步事件对应的记录任务；该第一同步事件对应的记录任务用于指示第一同步事件已经发生，该第一同步事件对应的记录任务中包括第二队列标识，以及第一同步寄存器的标识，该第二队列标识为第一同步事件对应的记录任务所在的队列的标识；第二处理器，还用于接收第一同步事件对应的记录任务，并基于第一同步寄存器的标识，将第一同步寄存器的值重置为第二数值。

结合第四方面和上述可能的实现方式，在另一种可能的实现方式中，上述同步装置还包括第三处理器，第三处理器包括第二NPU；上述第一处理器，还用于通过调用第三API，向该第三处理器发送第一同步事件对应的记录任务；该第一同步事件对应的记录任务用于指示上述第一同步事件已经发生，该第一同步事件对应的记录任务中包括第二队列标识，以及第一同步寄存器的标识，该第二队列标识为该第一同步事件对应的记录任务所在的队列的标识；第三处理器，用于接收该第一同步事件对应的记录任务，并基于第一同步寄存器的标识，将第一同步寄存器的值重置为第二数值。

结合第四方面和上述可能的实现方式，在另一种可能的实现方式中，若上述第一同步事件为进程间的同步事件；上述第一处理器，还用于通过调用第一应用程序的第四API，将第一同步对象的名称设置为预设名称；第一处理器，还用于通过调用第二应用程序的第五API，获取该预设名称对应的第一同步寄存器的标识。

结合第四方面和上述可能的实现方式，在另一种可能的实现方式中，上述第一同步事件为上述第一应用程序和上述第二应用程序之间的同步事件，上述预设名称为该第一应用程序和该第二应用程序预先约定的名称。

结合第四方面和上述可能的实现方式，在另一种可能的实现方式中，上述第一处理器，还用于通过调用第六API，获取第二同步寄存器的虚拟地址；该第二同步寄存器为第二同步事件对应的寄存器，该第二同步寄存器的不同值用于指示第二同步事件是否发生；第一处理器，还用于向第四处理器发送第二同步寄存器的虚拟地址；第一处理器和第四处理器为不同AI服务器中的处理器，第四处理器包括第二CPU。

结合第四方面和上述可能的实现方式，在另一种可能的实现方式中，上述第一处理器，还用于通过调用第七API，解除上述第一同步寄存器与上述第一同步事件的对应关系，并将上述第一同步寄存器的值重置为上述第一数值；该第七API用于释放上述第一同步寄存器。

结合第四方面和上述可能的实现方式，在另一种可能的实现方式中，上述第一同步寄存器的物理地址采用全局编址方式编址。

本申请实施例的第五方面，提供一种同步装置，该同步装置包括第四处理器和第五处理器；第四处理器，用于接收来自第一处理器的第二同步寄存器的虚拟地址；该第二同步寄存器为第二同步事件对应的寄存器，该第二同步寄存器的值包括第一数值或第二数值，第一数值用于指示第二同步事件未发生，第二数值用于指示第二同步事件已经发生；该第一处理器和该第四处理器为不同AI服务器中的处理器；第一处理器包括第一中央处理器CPU，第四处理器包括第二CPU；第四处理器，还用于向第五处理器发送第二同步事件对应的远程直接内存存取RDMA任务；第二同步事件对应的RDMA任务用于指示第二同步事件已经发生，第二同步事件对应的RDMA任务中包括第二同步寄存器的虚拟地址；第五处理器包括第三NPU；第五处理器，用于接收第二同步事件对应的RDMA任务，并基于第二同步寄存器的虚拟地址，通过RDMA装置将第二同步寄存器的值重置为第二数值。

可选的，第四处理器可以通过调用第八应用程序接口API，向第五处理器发送第二同步事件对应的RDMA任务。

本申请实施例的第六方面，提供一种同步装置，该同步装置包括第四处理器；该第四处理器，用于接收来自第一处理器的第二同步寄存器的虚拟地址，第二同步寄存器为第二同步事件对应的寄存器，第二同步寄存器的值包括第一数值或第二数值，第一数值用于指示第二同步事件未发生，第二数值用于指示第二同步事件已经发生；第一处理器和第四处理器为不同AI服务器中的处理器；第一处理器包括第一中央处理器CPU，第四处理器包括第二CPU；第四处理器，还用于基于第二同步寄存器的虚拟地址，通过远程直接内存存取RDMA装置将第二同步寄存器的值重置为第二数值。

上述第四方面的效果描述可以参考第一方面的效果描述，上述第五方面的效果描述可以参考第二方面的效果描述，上述第六方面的效果描述可以参考第三方面的效果描述，在此不再赘述。

本申请实施例的第七方面，提供一种第一处理器，该第一处理器，用于为第一同步事件创建第一同步对象；该第一同步对象中包括第一同步寄存器的标识；该第一寄存器的值包括第一数值或第二数值，第一数值用于指示同步事件未发生，第二数值用于指示同步事件已经发生；该第一处理器包括第一中央处理器CPU。

可选的，第一处理器还用于将上述第一寄存器的值重置为第一数值。

结合第七方面，在一种可能的实现方式中，上述第一处理器，具体用于通过调用第一应用程序接口API，在第二处理器包括的多个同步寄存器中为第一同步事件分配第一同步寄存器，并在第一同步对象中保存第一同步寄存器的标识。

结合第七方面和上述可能的实现方式，在另一种可能的实现方式中，上述第一处理器，还用于通过调用第二API，向第二处理器发送第一同步事件对应的等待任务；该第一同步事件对应的等待任务用于等待第一同步事件发生，该第一同步事件对应的等待任务包括第一队列标识，以及第一同步寄存器的标识；第一队列标识为等待任务所在的队列的标识。

结合第七方面和上述可能的实现方式，在另一种可能的实现方式中，上述第一处理器，还用于通过调用第三API，向上述第二处理器发送第一同步事件对应的记录任务；该第一同步事件对应的记录任务用于指示该第一同步事件已经发生，第一同步事件对应的记录任务中包括第二队列标识，以及第一同步寄存器的标识，第二队列标识为第一同步事件对应的记录任务所在的队列的标识。

结合第七方面和上述可能的实现方式，在另一种可能的实现方式中，上述第一处理器，还用于通过调用第三API，向第三处理器发送第一同步事件对应的记录任务；该第一同步事件对应的记录任务用于指示所述第一同步事件已经发生，该第一同步事件对应的记录任务中包括第二队列标识，以及第一同步寄存器的标识，该第二队列标识为第一同步事件对应的记录任务所在的队列的标识。

结合第七方面和上述可能的实现方式，在另一种可能的实现方式中，若上述第一同步事件为进程间的同步事件；上述第一处理器，还用于通过调用第一应用程序的第四API，将上述第一同步对象的名称设置为预设名称；该第一处理器，还用于通过调用第二应用程序的第五API，获取预设名称对应的第一同步寄存器的标识。

结合第七方面和上述可能的实现方式，在另一种可能的实现方式中，上述第一同步事件为上述第一应用程序和上述第二应用程序之间的同步事件，上述预设名称为第一应用程序和第二应用程序预先约定的名称。

结合第七方面和上述可能的实现方式，在另一种可能的实现方式中，上述第一处理器，还用于通过调用第六API，获取第二同步寄存器的虚拟地址；该第二同步寄存器为第二同步事件对应的寄存器，该第二同步寄存器的不同值用于指示第二同步事件是否发生；第一处理器，还用于向第四处理器发送该第二同步寄存器的虚拟地址；第一处理器和第四处理器为不同AI服务器中的处理器，第四处理器包括第二CPU。

结合第七方面和上述可能的实现方式，在另一种可能的实现方式中，上述第一处理器，还用于通过调用第七API，解除上述第一同步寄存器与上述第一同步事件的对应关系，并将上述第一同步寄存器的值重置为第一数值；第七API用于释放第一同步寄存器。

结合第七方面和上述可能的实现方式，在另一种可能的实现方式中，上述第一同步寄存器的物理地址采用全局编址方式编址。

本申请实施例的第八方面，提供一种第二处理器，该第二处理器包括多个同步寄存器，每个同步寄存器用于与一个同步事件相对应，每个同步寄存器的值包括第一数值或第二数值，第一数值用于指示同步寄存器对应的同步事件未发生，第二数值用于指示同步寄存器对应的同步事件已经发生；第二处理器包括第一神经网络处理器NPU。

结合第八方面，在一种可能的实现方式中，上述第二处理器，用于基于第一同步寄存器的值，确定第一同步事件是否发生。

结合第八方面和上述可能的实现方式，在另一种可能的实现方式中，上述第二处理器，具体用于在第一同步寄存器的值为第一数值的情况下，确定第一同步事件未发生，第二处理器继续等待第一同步事件发生，直至第一同步寄存器的值为第二数值，第二处理器确定第一同步事件已经发生，将第一同步寄存器的值重置为第一数值。

结合第八方面和上述可能的实现方式，在另一种可能的实现方式中，上述第二处理器，具体还用于在第一同步寄存器的值为第二数值的情况下，确定第一同步事件已经发生，将第一同步寄存器的值重置为第一数值。

结合第八方面和上述可能的实现方式，在另一种可能的实现方式中，上述第二处理器，还用于接收第一同步事件对应的等待任务；该第一同步事件对应的等待任务用于等待第一同步事件发生，第一同步事件对应的等待任务包括第一队列标识，以及第一同步寄存器的标识；第一队列标识为等待任务所在的队列的标识。

结合第八方面和上述可能的实现方式，在另一种可能的实现方式中，第二处理器，还用于接收第一同步事件对应的记录任务，并基于第一同步寄存器的标识，将第一同步寄存器的值重置为第二数值；该第一同步事件对应的记录任务用于指示第一同步事件已经发生，第一同步事件对应的记录任务中包括第二队列标识，以及第一同步寄存器的标识，第二队列标识为第一同步事件对应的记录任务所在的队列的标识。

本申请实施例的第九方面，提供一种第四处理器，该第四处理器，用于接收来自第一处理器的第二同步寄存器的虚拟地址；第二同步寄存器为第二同步事件对应的寄存器，第二同步寄存器的值包括第一数值或第二数值，第一数值用于指示第二同步事件未发生，第二数值用于指示所述第二同步事件已经发生；第一处理器和第四处理器为不同AI服务器中的处理器；第一处理器包括第一中央处理器CPU，第四处理器包括第二CPU；该第四处理器，还用于向第五处理器发送第二同步事件对应的远程直接内存存取RDMA任务；第二同步事件对应的RDMA任务用于指示第二同步事件已经发生，第二同步事件对应的RDMA任务中包括第二同步寄存器的虚拟地址；第五处理器包括第三NPU。

本申请实施例的第十方面，提供一种第五处理器，该第五处理器，用于接收第二同步事件对应的RDMA任务，并基于第二同步寄存器的虚拟地址，通过RDMA装置将第二同步寄存器的值重置为第二数值；该第二同步事件对应的RDMA任务用于指示第二同步事件已经发生，第二同步事件对应的RDMA任务中包括第二同步寄存器的虚拟地址；第五处理器包括第三NPU；第二同步寄存器的值包括第一数值或第二数值，第一数值用于指示第二同步事件未发生，第二数值用于指示第二同步事件已经发生。

本申请实施例的第十一方面，提供一种电子设备，该电子设备包括存储器，以及如上述第四方面、第五方面、第六方面中任一所述的同步装置。

本申请实施例的第十二方面，提供一种芯片，所述芯片包括接口电路，以及如上述第一方面所述的第一处理器，所述第一处理器用于通过所述接口电路与其它装置通信，以实现上述第一方面所述的方法。

本申请实施例的第十三方面，提供一种芯片，所述芯片包括接口电路，以及如上述第一方面所述的第一处理器和第二处理器，所述第一处理器和所述第二处理器通过所述接口电路通信，以实现上述第一方面所述的方法。

本申请实施例的第十四方面，提供一种芯片，所述芯片包括接口电路，以及如上述第一方面所述的第一处理器、第二处理器和第三处理器，所述第一处理器、所述第二处理器和所述第三处理器通过所述接口电路通信，以实现上述第一方面所述的方法。

本申请实施例的第十五方面，提供一种芯片，所述芯片包括接口电路，以及如上述第二方面或第三方面所述的第四处理器和第五处理器，所述第四处理器和所述第五处理器通过所述接口电路通信，以实现上述任一方面所述的方法。

本申请实施例的第十六方面，提供一种AI服务器，所述AI服务器包括CPU和一个或多个AI加速器，所述CPU为上述任一方面所述的第一处理器，所述一个或多个AI加速器包括上述任一方面所述的第二处理器或第三处理器中的至少一种。

本申请实施例的第十七方面，提供一种AI服务器，所述AI服务器包括CPU和一个或多个AI加速器，所述CPU为上述任一方面所述的第四处理器，所述AI加速器为上述任一方面所述的第五处理器。

本申请实施例的第十八方面，提供一种AI集群，该AI集群包括多个AI服务器，所述AI服务器包括CPU和一个或多个AI加速器，所述CPU包括上述任一方面所述的第一处理器，所述AI加速器包括上述任一方面所述的第二处理器或第三处理器中的至少一种。

本申请实施例的第十九方面，提供一种AI集群，该AI集群包括多个AI服务器，所述AI服务器包括CPU和一个或多个AI加速器，所述CPU包括上述任一方面所述的第四处理器，所述AI加速器包括上述任一方面所述的第五处理器。

本申请实施例的第二十方面，提供一种通信系统，该通信系统包括AI加速器、上述第十一方面所述的AI服务器、上述第十二方面所述的AI服务器、上述第十三方面所述的AI集群，或上述第十四方面所述的AI集群中的至少一种。该AI加速器包括上述任一方面所述的第二处理器、第三处理器、第五处理器中的至少一种。

本申请实施例的第二十一方面，提供一种应用程序接口API，该API部署在处理器中，该API用于为同步事件创建同步对象。可选的，该API可以为NotifyCreat(deviceID，notify)，其中，输入deviceID为AI加速器的ID，输出notify为同步对象。

本申请实施例的第二十二方面，提供一种应用程序接口API，该API部署在处理器中，该API用于下发同步事件对应的等待任务。可选的，该API可以为NotifyWait(notify，stream)接口，该接口用于在stream等待同步对象对应的同步事件发生。

本申请实施例的第二十三方面，提供一种应用程序接口API，该API部署在处理器中，该API用于下发同步事件对应的记录任务。可选的，该API可以为NotifyRecord(notify，stream)接口，该接口用于在stream设置同步对象对应的同步事件发生。

本申请实施例的第二十四方面，提供一种应用程序接口API，该API部署在处理器中，该API用于设置同步对象的全局名称。可选的，该API可以为IpcSetNotifyName(notify，name)，用于设置同步对象notify的全局名称。

本申请实施例的第二十五方面，提供一种应用程序接口API，该API部署在处理器中，该API用于打开同步对象。可选的，该API可以为IpcOpenNotify(notify，name)，用于根据同步对象notify的全局名称name，打开同步对象。

本申请实施例的第二十六方面，提供一种应用程序接口API，该API部署在处理器中，该API用于获取同步对象对应的寄存器的虚拟地址。可选的，该API可以为NotifyGetAddr(notify，addr)，其中输入为同步对象notify，输出为同步对象notify对应的同步寄存器的虚拟地址。

本申请实施例的第二十七方面，提供一种应用程序接口API，该API部署在处理器中，该API用于释放同步寄存器。可选的，该API可以为NotifyDestroy(notify)，该接口可以用于销毁同步对象notify，释放同步对象对应的同步寄存器。

本申请实施例的第二十八方面，提供一种应用程序接口API，该API部署在处理器中，该API用于下发同步事件对应的RDMA任务。可选的，该API可以为RDMAsend(addr，1)，用于指示向虚拟地址addr写入第二数值1。

附图说明

图1A为本申请实施例提供的一种AI训练过程的示意图；

图1B为本申请实施例提供的一种单AI服务器内的Ring算法的结构示意图；

图1C为本申请实施例提供的一种单AI服务器内的Ring算法中reduce-scatter阶段的计算过程示意图；

图1D为本申请实施例提供的一种单AI服务器内的Ring算法中all-gather阶段的计算过程示意图；

图2A为本申请实施例提供的一种AI加速器的结构示意图；

图2B为本申请实施例提供的一种计算架构的结构示意图；

图3为本申请实施例提供的一种同步方法的流程示意图；

图4为本申请实施例提供的一种AI服务器的计算架构的结构示意图；

图5为本申请实施例提供的一种计算任务的示意图；

图6为本申请实施例提供的另一种同步方法的流程示意图；

图7为本申请实施例提供的一种进程间同步的计算架构的结构示意图；

图8为本申请实施例提供的另一种同步方法的流程示意图；

图9为本申请实施例提供的另一种同步方法的流程示意图；

图10为本申请实施例提供的一种AI服务器间同步的计算架构的结构示意图；

图11为本申请实施例提供的另一种同步方法的流程示意图。

具体实施方式

下面将结合本申请实施例中的附图，对本申请实施例中的技术方案进行描述。在本申请中，“至少一个”是指一个或者多个，“多个”是指两个或两个以上。“和/或”，描述关联对象的关联关系，表示可以存在三种关系，例如，A和/或B，可以表示：单独存在A，同时存在A和B，单独存在B的情况，其中A，B可以是单数或者复数。字符“/”一般表示前后关联对象是一种“或”的关系。“以下至少一项(个)”或其类似表达，是指的这些项中的任意组合，包括单项(个)或复数项(个)的任意组合。例如，a，b或c中的至少一项(个)，可以表示：a，b，c，a和b，a和c，b和c，或，a和b和c，其中a、b和c可以是单个，也可以是多个。另外，为了便于清楚描述本申请实施例的技术方案，在本申请的实施例中，采用了“第一”、“第二”等字样对功能和作用基本相同的相同项或相似项进行区分，本领域技术人员可以理解“第一”、“第二”等字样并不对数量和执行次序进行限定。比如，本申请实施例中的第一处理器中的“第一”和第二处理器中的“第二”仅用于区分不同的处理器。本申请实施例中出现的第一、第二等描述，仅作示意与区分描述对象之用，没有次序之分，也不表示本申请实施例中对设备个数的特别限定，不能构成对本申请实施例的任何限制。

需要说明的是，本申请中，“示例性的”或者“例如”等词用于表示作例子、例证或说明。本申请中被描述为“示例性的”或者“例如”的任何实施例或设计方案不应被解释为比其他实施例或设计方案更优选或更具优势。确切而言，使用“示例性的”或者“例如”等词旨在以具体方式呈现相关概念。

人工智能场景(例如对神经网络进行训练)往往需要多个AI服务器组成集群来提供所需的算力。通常一个AI服务器可以包括一个或多个AI加速器。其中，AI加速器作为一种计算设备，可以是加速用于智能计算或其它数据密集或传感器驱动任务的机器学习过程或算法等专用任务的一类微处理器，还可以包括与该类微处理器相关的指令集。专用任务可以包括AI处理，例如人工神经网络，机器学习(machine learning，ML)训练，ML优化/学习，推断，分类等操作，可视数据处理，网络数据处理，对象检测，规则分析，内容处理操作等。AI加速器可以为神经网络处理器NPU，可包括图形处理单元GPU，数字信号处理器(digitalsignal processor，DSP)，片上系统(system on chip，SOC)，现场可编程门阵列(Field-Programmable Gate Array，FPGA)、专用集成电路(application specific integratedcircuit，ASIC)等中的一个或多个。AI加速器可以通过加载权值，偏置，训练数据或代码等运行相关的AI指令集以完成专用任务。本申请实施例对于AI加速器的具体形式并不限定。下述实施例以AI加速器为NPU为例进行说明。

如图1A所示，神经网络的训练过程一般包括多个迭代，每个迭代包括三个阶段：前向计算、反向计算和梯度汇聚。每个AI加速器分别独立的进行前向计算和反向计算，计算出的梯度需要在多个AI加速器上做汇聚。由于反向计算一般是进行误差的反向传播，在获取了误差(神经网络的识别值和监督数据之间的区别)后，基于梯度下降的方法来调整神经网络的权重。所以，反向计算包括了“获取误差值”和“基于误差值进行反向传播”的过程，而后一个过程(误差反向传播的过程)包括了基于梯度来调整神经网络的层与层之间权重的过程。由于目前的主流AI模型(例如用于图像识别的卷积神经网络)一般都包括多个神经元“Layer(层)”，而反向传播过程是将误差值从神经网络的输出层依次、反向地向神经网络的输入层传播过去，在反向传播的过程中，基于误差计算权重参数的梯度，并且进而依据权重参数的梯度的方向对神经网络的权重进行更新。因此，在反向计算过程中，当部分神经元层的梯度数值计算出来后，就可以开始梯度汇聚，例如：对于一个100层的神经网络而言，可以在第100-80层的梯度计算完成后即可开始梯度汇聚。如此一来，反向计算全部完成后，剩下的数据进行梯度汇聚的时间，较所有数据进行梯度汇聚的时间短，能够提高训练效率。

上述前向计算和反向计算过程由每个AI加速器完成，梯度汇聚主要包括AI服务器内的多个AI加速器间的数据传输、AI服务器之间的网络传输、AI加速器之间的同步等待、AI加速器之间的梯度数据累加等，梯度汇聚不需要AI加速器的计算单元参与，因此梯度汇聚时AI加速器的计算单元处于空闲状态。

例如，如图1A所示，在T0时刻至T1时刻AI加速器进行前向计算，在T1时刻至T2时刻AI加速器进行反向计算。在反向计算的过程中，为了提高训练效率，可以在T1时刻至T4时刻计算出部分数据后，从T4时刻开始进行梯度汇聚。即T4时刻至T2时刻同时进行反向计算和梯度汇聚1，待反向计算完成后，T2时刻至T3时刻仅进行剩余数据的梯度汇聚。因此，T0时刻至T2时刻为计算耗时，而T2时刻至T3时刻AI加速器的计算单元既不进行正向计算，也不进行反向计算，处于空闲态，由于AI集群仅进行梯度汇聚，该T2时刻至T3时刻也可以称为梯度汇聚时间。

示例性的，上述梯度汇聚时，可以采用All-reduce算法，该All-reduce算法为一类算法，用于高效地将不同AI加速器中的数据整合之后，再把结果分发给各个AI加速器。

梯度汇聚性能是体现集群训练性能的关键因素，梯度汇聚的时间越短，集群的线性度就越高。该集群的线性度L可以通过以下公式计算：

L＝(计算耗时)/(计算耗时+T_idle)；

其中，T_idle为AI加速器的计算单元处于空闲态的时间，即T_idle为梯度汇聚时间(例如，All-reduce时间)。该梯度汇聚时间越长，AI加速器的计算单元处于空闲态的时间就越长，集群线性度L越低。该梯度汇聚时间越短，AI加速器的计算单元处于空闲态的时间就越短，集群线性度L越高。

例如，如图1A所示，由于T2时刻至T3时刻进行的梯度汇聚2不需要AI加速器的计算单元的参与，AI加速器的计算单元处于空闲态，即T2时刻至T3时刻为梯度汇聚时间。因此T2时刻至T3时刻的时长越短，集群线性度越高，T2至T3的时长越长，集群线性度越低，故可以通过减少梯度汇聚时的同步传输及同步等待时间，提高集群线性度。

示例性，以集群的梯度汇聚算法为单AI服务器内的Ring算法为例，若AI服务器包括5块AI加速器，例如为GPU0至GPU4。该Ring算法包括2个阶段，分别为reduce-scatter阶段和all-gather阶段。在reduce-scatter阶段，GPU之间交换数据，使得每个GPU最终得到最终结果的一部分。在all-gather阶段，GPU将交换这些块，以便所有GPU最终得到完整的最终结果。

可选的，在Ring算法中，每个GPU都有一个左邻居和一个右邻居，而且每个GPU只会向它的右邻居发送数据，并从它的左邻居接收数据。例如，如图1B所示，以AI服务器包括5个GPU，分别为GPU0至GPU4为例，每个GPU都有一个左邻居和一个右邻居，GPU0只会向它的右邻居GPU1发送数据，并从它的左邻居GPU4接收数据。GPU1只会向它的右邻居GPU2发送数据，并从它的左邻居GPU0接收数据。GPU2只会向它的右邻居GPU3发送数据，并从它的左邻居GPU1接收数据。GPU3只会向它的右邻居GPU4发送数据，并从它的左邻居GPU2接收数据。GPU4只会向它的右邻居GPU0发送数据，并从它的左邻居GPU3接收数据。

例如，以AI服务器包括5个GPU，分别为GPU0至GPU4，每个GPU将数据分成5个较小的数据块为例，结合图1B，如图1C所示，在reduce-scatter阶段，每个GPU将进行4次迭代的reduce-scatter，在每次迭代中，每个GPU都会将其中一个数据块发送到其右邻居，并从其左邻居接收一个数据块并累积到该数据块中。每次迭代发送和接收的数据块均不同的。例如，GPU0将数据块a0发送至它的右邻居GPU1，并从它的左邻居GPU4接收数据块e4，并累积到数据块e0中。GPU1将数据块b1发送至它的右邻居GPU2，并从它的左邻居GPU0接收数据块a0，并累积到数据块a1中，以此类推。如图1C所示，在reduce-scatter阶段，GPU0至GPU4经过4次迭代后，每个GPU的一个数据块可以得到一个最终值。

为了实现All-reduce，结合图1B，如图1D所示，在all-gather阶段，GPU0至GPU4再次进行4次迭代，只是在每次迭代中，GPU都会将其中一个数据块发送到其右邻居，并从其左邻居接收一个数据块并覆盖到该数据块中。例如，GPU0将数据块b2+b1+b3+b4+b0发送至它的右邻居GPU1，并从它的左邻居GPU4接收数据块a1+a0+a2+a3+a4，并用数据块a1+a0+a2+a3+a4覆盖数据块a0。GPU1将数据块c3+c2+c4+c0+c1发送至它的右邻居GPU2，并从它的左邻居GPU0接收数据块b2+b1+b3+b4+b0，并用数据块b2+b1+b3+b4+b0覆盖数据块b1，以此类推。如图1D所示，在all-gather阶段，GPU0至GPU4经过4次迭代后，所有GPU都具有整个数组的完全累积值。

结合图1B、图1C和图1D可知，该梯度汇聚算法中GPU之间需要有同步机制，才能确保All-reduce得到的结果是正确的。例如，GPU1必须在GPU0把a0传给GPU1后，GPU1才能把a0+a1传给GPU2，如果GPU1提前把结果传给GPU2，则All-reduce结果不正确，如果GPU1延迟将结果传给GPU2，则All-reduce时间较长，浪费GPU的计算算力，因此需要合理的同步机制既确保AI算法正确运行，又能提高AI加速器的算力。

可以理解的，本申请实施例以单AI服务器内的Ring算法为例，说明在AI训练场景中需要同步机制才能确保算法的正常运行，本申请实施例对于同步机制的具体适用场景并不进行限定。实际应用中，当多个AI服务器组成集群进行AI训练时，为了减少一个AI加速器内、一个AI服务器内的不同AI加速器间，以及AI服务器间的同步传输及同步等待时间，提供一种合理的同步机制是非常有必要的。

一种同步机制是通过信号量(semaphore)机制，确保进程内和进程间的同步互斥。但是该方法只支持在通用处理器架构(例如，X86或ARM)上进行同步，不支持在AI加速器等芯片上的同步，而且不支持AI服务器间的同步。

另一种同步方法是英伟达NVIDIA的统一计算设备架构(compute unified devicearchitecture，CUDA)提供的事件event同步机制，该event同步机制用于进程内、进程间，图形处理器(graphics processing unit，GPU)片内、GPU片间的同步。但是，event机制不支持AI服务器间的同步，在GPU片内、GPU片间进行同步时的开销较大，在10us量级，而且event机制用于进程间同步时，应用程序接口(application program interface，API)设计比较复杂，不方便开发者使用。

本申请实施例提供一种同步方法，该方法能够实现一个AI加速器内、一个AI服务器内的不同AI加速器间，以及AI服务器间的同步，而且同步开销较小，API设计较简单，方便开发者使用。

本申请实施例提供的同步方法，可以应用于一种计算架构，该计算架构可以为AI服务器的计算架构。该AI服务器的计算架构为异构计算的硬件架构，该架构中包括中央处理器(central processing unit，CPU)以及一个或多个AI加速器。其中，CPU可以向AI加速器发送AI计算任务，AI加速器接收CPU发送的AI计算任务后，执行该AI计算任务，并将执行结果上报给CPU。

图2A为本申请实施例提供的一种AI加速器，如图2A所示，该AI加速器包括控制器、运算逻辑单元和多个同步寄存器。

控制器用于接收CPU发送的AI计算任务，并将该计算任务的执行结果上报给CPU。

运算逻辑单元用于执行控制器下发的计算任务，并向控制器返回每个计算任务的执行结果。

如图2A所示，AI加速器中包括多个同步寄存器，该多个同步寄存器分别为Reg0、Reg1至Regn。每个同步寄存器用于与一个同步事件相对应，该同步寄存器的不同值可以用于指示其对应的同步事件是否发生。可选的，如图2A所示，该多个同步寄存器可以设置在AI加速器的控制器中。

示例性的，每个同步寄存器的值可以包括第一数值和第二数值。第一数值用于指示该同步寄存器对应的同步事件未发生，该第二数值用于指示该同步寄存器对应的同步事件已经发生。该第一数值和第二数值为不同的数值。本申请实施例对于第一数值和第二数值的具体取值并不限定，下述实施例以第一数值为0，第二数值为1进行示例性说明。

可选的，同步寄存器对应的同步事件可以发生在一个AI加速器内，也可以发生在一个AI服务器内的不同AI加速器之间，还可以发生在不同AI服务器之间(每个AI服务器包括至少一个AI加速器)。可以理解的，当同步寄存器对应的同步事件发生在一个AI加速器内时，该AI加速器可以基于该同步寄存器的值，确定该同步事件是否发生，从而实现AI加速器内的同步。当同步寄存器对应的同步事件发生在一个AI服务器内的不同AI加速器之间时，AI加速器可以基于该同步寄存器的值，确定该同步事件是否发生，从而实现一个AI服务器内的不同AI加速器间的同步。当同步寄存器对应的同步事件发生在不同AI服务器之间时，一个AI服务器的AI加速器可以基于该同步寄存器的值，确定该同步事件是否发生，从而实现AI加速器间的同步。

可选的，本申请实施例对于每个AI加速器内设置的同步寄存器的具体数量并不做限定。例如，以AI加速器同时最多支持1024个同步事件为例，可以在AI加速器中设置1024个同步寄存器，一个同步寄存器可以与一个同步事件相对应。

可以理解的，本申请实施例提供的AI加速器，通过在AI加速器中设置多个同步寄存器，而且每个同步寄存器用于与一个同步事件相对应，从而使得AI加速器可以基于该同步寄存器的值，确定该同步寄存器对应的同步事件是否发生，以实现一个AI加速器内、一个AI服务器内的不同AI加速器间，以及AI服务器间的同步。

本申请实施例提供的同步方法，可以应用于图2B所示的AI服务器，如图2B所示，该AI服务器可以包括CPU和多个AI加速器，每个AI加速器中包括一组同步寄存器，每个同步寄存器可以与一个同步事件相对应，该同步寄存器的不同值可以用于指示其对应的同步事件是否发生。

如图2B所示，CPU中的驱动用于为AI加速器提供驱动功能。应用程序(application，App)中部署用户态驱动层运行时(runtime)，runtime用于提供AI加速器的用户态驱动功能。例如，runtime中包括多个API，CPU运行APP时，可以通过调用不同的API接口实现软件与硬件间的交互。CPU可以通过调用API向AI加速器发送AI计算任务，AI加速器中的控制器接收CPU发送的AI计算任务后，执行该AI计算任务，并将执行结果上报给CPU。

可选的，APP的用户态驱动层runtime提供API。上层业务APP可以将AI模型(计算图)进行分拆，转换成AI加速器能够处理的stream、task、event等任务，通过runtime提供的API分别下发给AI加速器处理。示例性的，task是计算任务，一般由AI加速器中的运算逻辑单元处理。event是事件同步机制，一般由控制器处理。AI加速器中的控制器可以并发调度多个stream的task执行，但是同一个stream里的task只能顺序执行。

可选的，当AI服务器包括多个AI加速器时，不同AI加速器内设置的同步寄存器的数量可以相同，也可以不同，本申请实施例对此并不限定，图2B中以AI服务器包括m+1个AI加速器，AI加速器0和AI加速器m中均设置n个同步寄存器为例进行示意。

可选的，当AI服务器包括多个AI加速器时，每个AI加速器中可以设置多个同步寄存器，一个AI服务器内的不同AI加速器中设置的同步寄存器的物理地址可以采用全局编址方式编址。例如，可以根据AI加速器的标识(identity，ID)加偏移或其他方式，实现一个AI服务器内的同步寄存器的全局编址。可以理解的，由于AI服务器内的多个AI加速器中的同步寄存器采用全局编址，因此每个AI加速器的控制器，可以获知AI服务器内其他AI加速器中的同步寄存器的物理地址，同时也可以通过物理地址，访问其他AI加速器的同步寄存器。

示例性的，当AI服务器中仅包括一个AI加速器时，该AI加速器和CPU可以集成在一个芯片上，也可以分别集成在不同的芯片上。当计算架构中包括多个AI加速器时，该多个AI加速器可以集成在一个或多个芯片上，CPU可以集成在另一个芯片上，也可以将CPU和AI加速器集成在一个芯片上。本申请实施例对于AI服务器中CPU和AI加速器组成的异构计算的硬件形态并不进行限定，在此示例性说明。

可以理解的，本申请实施例通过在AI服务器内的AI加速器中设置一组同步寄存器，而且每个同步寄存器可以与一个同步事件相对应，从而使得AI加速器可以基于该同步寄存器的值，确定该同步寄存器对应的同步事件是否发生，能够实现一个AI加速器内、一个AI服务器内的不同AI加速器间，以及AI服务器间的同步。

结合上述图2A、图2B，如图3所示，为本申请实施例提供的一种同步方法，该方法包括以下步骤：

S301、第一处理器为第一同步事件创建第一同步对象。

第一处理器可以为AI服务器中的中央控制单元，例如，CPU。第一处理器包括第一CPU。

可选的，上述步骤S301中第一处理器为第一同步事件创建第一同步对象，可以包括：第一处理器通过调用第一API，在第二处理器包括的多个同步寄存器中，为第一同步事件分配第一同步寄存器，并在第一同步对象中保存第一同步寄存器的标识。该第二处理器包括第二NPU，而且该第二处理器为等待第一同步事件发生的NPU。即本申请实施例中为同步事件分配的同步寄存器为等待同步事件发生的NPU中的同步寄存器。

该第一API用于为同步事件创建同步对象。例如，该第一API可以为NotifyCreat(deviceID，notify)，其中输入deviceID为AI加速器的ID，输出notify为同步对象，该NotifyCreat接口用于创建同步对象。上述NotifyCreat接口中的deviceID为第二处理器的ID。

可选的，第一处理器为第一同步事件分配第一同步寄存器时，还可以将该第一同步寄存器的值重置为第一数值，使得第一同步寄存器的值与第一同步事件的当前状态相对应。上述将第一同步寄存器的值重置为第一数值，也可以是将第一同步寄存器的值设置为第一数值，本申请实施例对此并不限定。实际应用中，可以采用设置方式，也可以采用重置(Reset)方式改变同步寄存器的值。

可选的，上述第一处理器可以为AI服务器中的CPU，第二处理器可以为该AI服务器中的AI加速器，该第一处理器和第二处理器组成了异构的计算架构，该AI服务器可以为异构服务器。例如，第一处理器可以为AI服务器中的host CPU，第二处理器可以为AI服务器中的NPU，host CPU可以通过调用第一API，在等待同步事件发生的NPU包括的多个同步寄存器中，为第一同步事件分配第一同步寄存器。

可选的，上述第一同步事件可以发生在一个NPU内，也可以发生在一个AI服务器内的不同NPU之间，还可以发生在不同AI服务器之间，本申请实施例对此并不限定。

示例性的，图4为一种AI服务器的计算架构的结构示意图。如图4所示，以AI加速器为NPU，AI服务器包括CPU和两个NPU，两个NPU分别为NPU0和NPU1为例，CPU可以向NPU0和NPU1下发计算任务、记录任务和等待任务。其中，计算任务(Task)是由运算逻辑单元处理的计算任务，记录任务(record)用于指示同步事件已经发生，等待任务(wait)用于等待同步事件发生。

例如，以同步事件发生在AI加速器内为例，结合图4，如图5中的(a)所示，NPU0的队列0执行完计算任务01后，NPU0的队列1才可以执行计算任务12。该同步需要NPU0的队列1等待同步事件1发生，该同步事件1为NPU0的队列0执行完计算任务01并发送执行结果。在同步事件1未发生时，NPU0的队列1执行完计算任务11后，一直保持等待。在同步事件1已经发生(NPU0的队列0执行完计算任务01，并发送执行结果)时，NPU0的队列0可以继续执行计算任务12。可以理解的，同步事件1发生在AI加速器NPU0的两个不同队列之间。

再例如，以同步事件发生在一个AI服务器内的不同AI加速器间为例，结合图4，如图5中的(b)所示，NPU0的队列2执行完计算任务3n后，NPU1的队列1才可以执行计算任务2n。该同步需要NPU1的队列1等待同步事件2发生，该同步事件2为NPU0的队列2执行完计算任务3n，并发送执行结果。在同步事件2未发生时，NPU1的队列1一直保持等待。在同步事件2已经发生时，NPU1的队列1可以继续执行计算任务2n。可以理解的，同步事件2发生在一个AI服务器内的不同AI加速器之间(NPU0和NPU1之间)。

示例性的，对于上述同步事件1，由NPU0的队列1等待同步事件1发生，因此CPU可以在NPU0包括的多个同步寄存器中为同步事件1分配同步寄存器，并在同步对象1中保存该同步寄存器的标识，该同步对象1可以记为notify1。对于上述同步事件2，由NPU1的队列1等待同步事件2发生，因此CPU可以在NPU1包括的多个同步寄存器中为同步事件2分配同步寄存器，并在同步对象2中保存该同步寄存器的标识，该同步对象2可以记为notify2。

可选的，由于本申请实施例在每个NPU内设置一组同步寄存器，因此在APP确定需要进行同步时，可以通过调用NotifyCreat(deviceID，notify)接口，在等待同步事件发生的NPU上为每个同步事件分配一个同步寄存器。

例如，对于图5中的(a)所示的同步事件1，APP下发NotifyCreate的API，在NPU0上创建同步对象notify1，Runtime调用NPU驱动的接口，请求NPU驱动在NPU0上为同步事件分配一个同步寄存器。如图4所示，NPU驱动可以在NPU0中的多个同步寄存器中分配一个同步寄存器Reg0，记录该同步寄存器Reg0的标识，并将该同步寄存器的值重置为第一数值0。NPU驱动返回该同步寄存器Reg0的id给Runtime，Runtime构建好同步对象notify1，将同步寄存器Reg0的id保存在notify1中，将notify1返回给APP。

再例如，对于图5中的(b)所示的同步事件2，APP下发NotifyCreate的API，在NPU1上创建同步对象notify2，Runtime调用NPU驱动的接口，请求NPU驱动在NPU1上为同步事件分配一个同步寄存器。如图4所示，NPU驱动可以在NPU1中的多个同步寄存器中分配一个同步寄存器Reg1，记录该同步寄存器Reg1的标识，并将该同步寄存器Reg1的值重置为第一数值0。NPU驱动返回该同步寄存器Reg1的id给Runtime，Runtime构建好同步对象notify2，将同步寄存器Reg1的id保存在notify2中，将notify2返回给APP。

可选的，NPU驱动在为同步事件分配同步寄存器时，可以将NPU中处于空闲状态的同步寄存器分配给该同步事件。可以理解的，该NPU中处于空闲状态的同步寄存器是指未与其他同步事件关联过的同步寄存器，或者，虽与其他同步事件关联过但已经被回收(即与其他同步事件或同步对象解除关联关系)的同步寄存器。

本申请实施例中的同步事件可以发生在一个NPU内，也可以发生在一个AI服务器内的不同NPU之间，还可以发生在不同AI服务器的NPU(每个AI服务器包括至少一个NPU)之间。本实施例以图5中的(a)以同步事件1发生在一个NPU内，图5中的(b)以同步事件2发生在一个AI服务器内的不同NPU之间为例进行说明。

S302、第二处理器基于第一同步寄存器的值，确定第一同步事件是否发生。

可选的，由于该第一同步寄存器的不同值用于指示第一同步事件是否发生。因此第二处理器基于第一同步寄存器的值，确定第一同步事件是否发生，可以分为以下两种实现方式。

第一种实现方式，上述步骤S302可以包括：在第一同步寄存器的值为第一数值的情况下，第二处理器确定第一同步事件未发生，第二处理器继续等待第一同步事件发生，直至第一同步寄存器的值为第二数值，第二处理器确定第一同步事件已经发生，第二处理器将第一同步寄存器的值重置为第一数值。

示例性的，如果第一同步寄存器的值为第一数值，表示第一同步事件未发生，那么第二处理器将继续等待第一同步事件发生，直到第一同步寄存器的值为第二数值时，第二处理器将第一同步寄存器的值重置为第一数值，再执行接下来的任务，从而能够确保正确同步。

可选的，在第一同步寄存器的值为第一数值的情况下，第二处理器的控制器会一直检查第一同步寄存器的取值。当第一同步寄存器的值从0变为1时，由于第一同步寄存器为第二处理器中的同步寄存器，因此第二处理器的控制器可以立刻检查到第一同步寄存器的取值修改，第二处理器确定第一同步事件已经发生，第二处理器将第一同步寄存器清0，以便第一同步寄存器可以继续进行同步操作。

第二种实现方式，上述步骤S302可以包括：在第一同步寄存器的值为第二数值的情况下，第二处理器确定第一同步事件已经发生，第二处理器将第一同步寄存器的值重置为第一数值。

示例性的，如果第一同步寄存器的值为第二数值，那么第二处理器确定第一同步事件已经发生，第二处理器将第一同步寄存器的值重置为第一数值。然后第二处理器可以继续执行后续的任务，从而能够确保正确同步。

本申请实施例提供的同步方法，通过为第一同步事件创建第一同步对象，从而使得第一同步事件可以与第一同步寄存器相对应，AI加速器可以基于该同步寄存器的值，确定该同步寄存器对应的同步事件是否发生，从而能够实现一个AI加速器内、一个AI服务器内的不同AI加速器间，以及AI服务器间的同步。

图6为本申请实施例提供的一种同步方法，如图6所示，该方法可以包括以下步骤：

S601、第一处理器为第一同步事件创建第一同步对象。

可选的，该第一同步事件可以发生在一个NPU内，也可以发生在一个AI服务器内的不同NPU间。

可以理解的，步骤S601的具体实现方式可以参考步骤S301，在此不再赘述。

S602、第一处理器通过调用第二API，向第二处理器发送第一同步事件对应的等待任务。

第二API用于下发同步事件对应的等待任务。例如，该第二API可以为NotifyWait(notify，stream)接口，该接口用于在stream等待同步对象对应的同步事件发生。

第一同步事件对应的等待任务用于等待第一同步事件发生，该第一同步事件对应的等待任务中包括第一队列标识，以及第一同步寄存器的标识。第一队列标识为等待任务所在的队列的标识。即第一同步事件对应的等待任务为第一队列中的任务。可选的，该第一队列标识可以为等待任务所在的stream的标识。

例如，结合图4，如图5中的(a)所示，对于同步事件1，CPU通过调用NotifyWait(notify1，队列1)，向NPU0下发Wait等待任务1，指示NPU0在队列1等待notify1对应的同步事件1发生。

再例如，结合图4，如图5中的(b)所示，对于同步事件2，CPU通过调用NotifyWait(notify2，队列1)，向NPU1下发等待任务2，指示NPU1在队列1等待notify2对应的同步事件2发生。

S603、第二处理器接收第一同步事件对应的等待任务。

S604、第二处理器基于第一同步寄存器的值，确定第一同步事件是否发生。

可选的，第二处理器接收第一同步事件对应的等待任务后，可以基于该等待任务中携带的第一同步寄存器的标识，读取该第一同步寄存器的值，由于该第一同步寄存器的不同值用于指示第一同步事件是否发生。因此第二处理器基于第一同步寄存器的值，确定第一同步事件是否发生。

可以理解的，步骤S604的具体实现方式可以参考步骤S302，在此不再赘述。

例如，结合图4和图5中的(a)，对于同步事件1，CPU通过NotifyWait向NPU0下发等待任务1，NPU0接收等待任务1后，基于等待任务1中的同步寄存器Reg0的标识，读取该Reg0的值。如果Reg0的值为0，说明notify1对应的同步事件1未发生，那么NPU0继续等待同步事件1发生，NPU0的控制器一直检查Reg0的取值。当Reg0的值从0变为1时，说明notify1对应的同步事件1已经发生，NPU0的控制器立刻检查到Reg0的取值修改，确定同步事件1已经发生，NPU0的控制器将Reg0的值清零。

再例如，结合图4和图5中的(a)，对于同步事件1，CPU通过NotifyWait向NPU0下发等待任务1，NPU0接收等待任务1后，基于等待任务1中的同步寄存器Reg0的标识，读取该Reg0的值。如果Reg0的值为1，NPU0确定notify1对应的同步事件1已经发生，NPU0的控制器将Reg0的值清零。

可选的，在第一同步事件发生后，第二处理器通过将第一同步寄存器的值重置为第一数值，从而使得该第一同步寄存器可以继续进行其他同步操作。例如，如果第一同步对象对应的同步事件周期性发生，那么可以在下次该第一同步对象对应的同步事件发生时，第二处理器基于该第一同步寄存器的值进行同步。

S605、第一处理器通过调用第三API，向第三处理器发送第一同步事件对应的记录任务。

该第三处理器可以为NPU，该第三处理器与上述第二处理器可以为同一个NPU，也可以为同一个AI服务器内的不同NPU。

第三API用于下发同步事件对应的记录任务。例如，该第三API可以为NotifyRecord(notify，stream)接口，该接口用于在stream设置同步对象对应的同步事件发生。

第一同步事件对应的记录任务用于指示第一同步事件已经发生，第一同步事件对应的记录任务中包括第二队列标识，以及第一同步寄存器的标识，第二队列标识为第一同步事件对应的记录任务所在的队列的标识。即第一同步事件对应的记录任务为第二队列中的任务。可选的，该第二队列标识可以为记录任务所在的stream的标识。

可选的，当第一同步事件发生在一个AI加速器内时，上述第二处理器和第三处理器为同一个AI加速器(例如，NPU)，即同一个AI加速器既执行Wait任务，又执行Record任务。当第一同步事件发生在一个AI服务器内的两个AI加速器之间时，上述第二处理器和第三处理器为AI服务器内的两个不同的AI加速器。即，一个AI加速器执行Wait任务，另一个AI加速器执行Record任务。可选的，AI加速器既执行Wait任务，又执行Record任务时，Wait任务和Record任务可以分别为两个Stream中的任务。

例如，结合图4，如图5中的(a)所示，以第一同步事件为同步事件1为例，该同步事件1发生在一个NPU内。对于同步事件1，上述第二处理器和第三处理器相同，均为NPU0，即NPU0既执行Wait任务，又执行Record任务。CPU通过调用NotifyRecord(notify1，队列0)，向NPU0下发记录任务1，指示NPU0的队列0中同步对象notify1对应的同步事件1已经发生。可选的，CPU可以在NPU0执行完计算任务01，并将计算任务01的执行结果发送给CPU后，CPU向NPU0下发记录任务1，指示notify1对应的同步事件1已经发生。

再例如，结合图4，如图5中的(b)所示，以第一同步事件为同步事件2为例，该同步事件2发生在AI服务器内的不同NPU间。对于同步事件2，上述第二处理器为NPU1，第三处理器为NPU0，CPU通过调用NotifyRecord(notify2，队列2)，向NPU0下发记录任务2，指示NPU0在队列2中同步对象notify2对应的同步事件2已经发生。可选的，CPU可以在NPU0执行完计算任务3n，并将计算任务3n的执行结果发送给CPU后，CPU向NPU0下发记录任务2，指示notify2对应的同步事件2已经发生。

S606、第三处理器接收第一同步事件对应的记录任务。

示例性的，第三处理器接收第一同步事件对应的记录任务，可以获知该第一同步事件已经发生。

S607、第三处理器基于第一同步寄存器的标识，将第一同步寄存器的值重置为第二数值。

由于第一同步事件已经发生，第三处理器可以基于第一同步事件对应的记录任务中的第一同步寄存器的标识，将该第一同步寄存器的值重置为第二数值，以使得第一同步寄存器的值与第一同步事件的发生状态相对应。

例如，结合图4和图5中的(a)所示，对于同步事件1，NPU0可以基于Reg0的标识将NPU0中的Reg0的值重置为1，从而NPU0的控制器可以立刻检查到Reg0的取值修改，NPU0确定同步事件1已经发生，将Reg0的值清零。

再例如，结合图4和图5中的(b)所示，对于同步事件2，NPU0可以基于Reg1的标识将NPU1中的Reg1的值重置为1，从而NPU1的控制器可以立刻检查到Reg1的取值修改，NPU1确定同步事件2已经发生，将Reg1的值清零。

可以理解的，在本申请实施例中，NotifyWait和NotifyRecord是一一对应的，第三处理器接收记录任务后，获知同步对象对应的同步事件已经发生，将该同步对象对应的同步寄存器的值重置为1。第二处理器接收等待任务后，读取该同步对象对应的同步寄存器的值，如果同步寄存器的值0，确定同步事件未发生，第二处理器将继续等待同步事件发生，直到第三处理器将该同步对象对应的同步寄存器的值置为1，第二处理器立刻检查到同步寄存器的值为1，那么第二处理器确定同步事件已经发生，第二处理器将该同步寄存器的值重置为0，以便该同步寄存器可以继续进行后续的其他同步操作。

需要说明的是，本实施例提供的同步方法中，同步开销为AI加速器的控制器通过总线写寄存器的开销，该同步开销较小。例如，采用本实施例提供的同步方法，对于一个NPU内的同步而言，同步开销小于50ns，对于一个AI服务器内的不同NPU间的同步，同步开销小于1us。而且本申请实施例提供了简单的API接口，和通用OS的semaphore接口类似，可以大大方便开发者使用AI加速器。

可以理解的，本申请实施例对于上述步骤S601-S607的具体执行顺序并不进行限定，图6仅是示例性说明。

可选的，上述方法还可以包括步骤S608。

S608、第一处理器通过调用第七API，解除第一同步寄存器与第一同步对象的对应关系，并将第一同步寄存器的值重置为第一数值。

第七API用于释放第一同步寄存器。例如，第七API可以为NotifyDestroy(notify)，该接口可以用于销毁同步对象notify，释放同步对象对应的同步寄存器。

例如，如图4所示，APP下发NotifyDestroy的API，销毁创建的同步对象notify1，runtime调用NPU驱动的接口，释放NPU0上的notify1，NPU驱动回收NPU0的notify 1，同时将notify 1对应的同步寄存器Reg0的值重置为0。

可以理解的，通过NotifyDestroy销毁同步对象，能够将该同步对象对应的同步寄存器回收，从而在后续需要进行同步时，可以将该同步寄存器分配给其他同步事件。

本申请实施例提供的同步方法，通过在AI加速器中设置一组同步寄存器，每个寄存器可以与一个同步事件相对应，该寄存器的不同取值用于指示其对应的同步事件是否发生。在AI加速器接收等待任务时，通过读取相应的同步寄存器的值，能够在同步事件未发生时，一直等待同步事件发生，在同步事件已经发生时，将该同步寄存器的值重置为第一数值。在AI加速器接收到记录任务时，通过在相应的同步寄存器中写入数值，指示同步事件已经发生，从而能够使得需要进行同步的AI加速器准确的实现同步。可以理解的，本申请实施例提供的同步方法，不仅可以通过同步寄存器实现一个AI加速器内的同步，也可以实现一个AI服务器内的不同AI加速器间的同步。而且提供了简单的API接口、同步开销较小，能够提升AI训练的效率。

可选的，上述第一同步事件可以是一个APP的同步事件，也可以是不同APP之间的同步事件。无论同步事件是一个APP的同步事件，该是多个APP之间的同步事件，该同步事件可以发生在一个AI加速器内，也可以发生在一个AI服务器内的不同AI加速器间。但是，当第一同步事件为多个APP之间的同步事件时，为了实现进程间的同步，需要该多个APP预先约定好同步对象的名称。例如，如图7所示，以第一同步事件为APP1和APP3之间的同步为例，在APP1和APP3之间需要进行同步时，APP1和APP3可以预先约定好同步对象的名称，从而实现不同进程间的同步。

本申请实施例还提供一种同步方法，如图8所示，在本实施例中第一同步事件为进程间的同步事件，该方法包括以下步骤：

S801、第一处理器为第一同步事件创建第一同步对象。

该第一同步事件为进程间的同步事件，该第一同步事件可以发生在一个AI加速器内，也可以发生在一个AI服务器内的不同AI加速器间，本申请实施例对此并不限定。

可以理解的，步骤S801的具体实现方式可以参考前述步骤S301的具体实现方式，在此不再赘述。

S802、第一处理器通过调用第一应用程序的第四API，将第一同步对象的名称设置为预设名称。

第四API用于设置同步对象的全局名称。例如，第四API可以为IpcSetNotifyName(notify，name)，用于设置同步对象notify的全局名称。

可选的，第一同步事件可以为第一应用程序和第二应用程序之间的同步，上述预设名称为该第一应用程序和第二应用程序预先约定的名称。

例如，以第一同步事件为APP1和APP3之间的同步，APP1和APP3预先约定的同步对象的名称为NotifyForTest1为例，如图7所示，APP1可以通过调用NotifyCreate接口，创建同步对象A，该同步对象A可以记为notifyA，NPU驱动将NPU1的同步寄存器Regn分配给APP1的runtime，notifyA中保存同步寄存器Regn的标识，图7中以该同步寄存器Regn的标识为1-n为例进行示例。APP1调用IpcSetNotifyName接口，将notifyA设置为进程间通信(interprocess communication，IPC)的同步对象，NPU驱动将同步对象notifyA的名称标记为NotifyForTest1。

S803、第一处理器通过调用第二应用程序的第五API，获取预设名称对应的第一同步寄存器的标识。

第五API用于获取预设名称对应的寄存器的标识。例如，该第五API可以为IpcOpenNotify(notify，name)，用于根据同步对象notify的全局名称name，打开同步对象。

例如，以第一同步事件为APP1和APP3之间的同步，APP1和APP3预先约定的同步对象的名称为NotifyForTest1为例，如图7所示，APP3调用IpcOpenNotify，runtime调用NPU驱动接口，传入NotifyForTest1，NPU驱动根据NotifyForTest1找到同步对象notifyA，返回notifyA中的同步寄存器的标识Reg1-n给runtime，runtime创建同步对象B给APP3，该同步对象B可以记为notifyB，notifyB中保存同步寄存器的标识Reg1-n。如此一来，同一个同步寄存器Reg1-n可以分别对应APP1的notifyA和APP3的notifyB，然后APP1和APP3就可以使用NotifyRecord和NotifyWait接口进行同步。

S804、第一处理器通过调用第二API，向第二处理器发送第一同步事件对应的等待任务。

例如，如图7所示，APP1可以调用NotifyWait(notifyA，队列1)接口，向NPU1下发等待任务，指示NPU1在队列1等待notifyA对应的同步事件发生。

S805、第二处理器接收第一同步事件对应的等待任务。

S806、第二处理器基于第一同步寄存器的值，确定第一同步事件是否发生。

例如，结合图7所示，CPU通过NotifyWait向NPU1下发等待任务，NPU1接收等待任务后，基于等待任务中的同步寄存器Reg1-n的标识，读取该Reg1-n的值。如果Reg1-n的值为0，说明notifyA对应的同步事件未发生，那么NPU1一直保持等待，NPU1的控制器一直检查Reg1-n的取值，当Reg1-n的值从0变为1时，说明notifyA对应的同步事件已经发生，NPU1的控制器立刻检查到Reg1-n的取值修改，NPU1的控制器结束等待，并将Reg1-n的值清零。

S807、第一处理器通过调用第三API，向第三处理器发送第一同步事件对应的记录任务。

可选的，当第一同步事件发生在一个AI加速器内时，第三处理器和第二处理器为同一个AI加速器。当第一同步事件发生在一个AI服务器内的不同AI加速器间时，第三处理器和第二处理器为一个AI服务器内的两个不同的AI加速器。下述实施例以第一同步事件发生在一个AI服务器内的不同AI加速器间为例进行说明。

例如，如图7所示，APP2可以调用NotifyRecord(notifyB，队列0)接口，向NPU0下发记录任务，指示NPU0在队列0中同步对象notifyB对应的同步事件已经发生。

S808、第三处理器接收第一同步事件对应的记录任务。

S809、第三处理器基于第一同步寄存器的标识，将第一同步寄存器的值重置为第二数值。

例如，如图7所示，NPU0可以基于Reg1-n的标识将NPU1中的Reg1-n的值重置为1，从而NPU1的控制器可以立刻检查到Reg1-n的取值修改，NPU1的控制器结束等待，并将Reg1-n的值清零。

可以理解的，上述步骤S804-S809的具体实现方式可以参考前述实施例中的步骤S602-S607的实现方式，在此不再赘述。

可以理解的，本申请实施例对于上述步骤S801-S809的具体执行顺序并不进行限定，图8仅是示例性说明。

可选的，上述方法还可以包括步骤S810。

S810、第一处理器通过调用第七API，解除第一同步寄存器与第一同步事件的对应关系，并将第一同步寄存器的值重置为第一数值。

可以理解的，上述步骤S810的具体实现方式可以参考步骤S608，在此不再赘述。

本申请实施例提供的同步方法，通过在AI加速器中设置一组用于同步的寄存器，每个寄存器可以用于与一个同步事件相对应，该寄存器的不同取值用于指示其对应的同步事件是否发生，而且在同步事件为进程间同步的情况下，通过预先设置同步事件的全局名称，从而能够将不同进程间的同步事件与同一个寄存器对应，以实现进程间的同步。

本申请实施例还提供一种芯片的同步方法，在本实施例中第二同步事件发生在不同AI服务器之间，如图9所示，该方法包括以下步骤：

S901、第一处理器为第二同步事件创建第二同步对象。

可以理解的，上述步骤S901的具体实现方式可以参考前述步骤S301，在此不再赘述。

第二同步事件为不同AI服务器间的同步事件。

例如，以第二同步事件为AI服务器1与AI服务器2之间的同步为例，如图10所示，AI服务器1中运行APP1，AI服务器2中运行APP2，APP1和APP2需要进行同步，APP1等待APP2传数据给APP1，APP2在数据传输完成后，通知APP1传输完成，指示APP1可以执行后续任务。对于该同步，可以由CPU1在AI服务器1的NPU0包括的多个同步寄存器中为该同步事件分配同步寄存器Regm，并在同步对象K中保存该同步寄存器Regm的标识Reg0-m，该同步对象K可以记为notifyK。比如，AI服务器1的CPU1可以通过调用NotifyCreat接口，创建同步对象notifyK，该同步对象notifyK中保存了NPU驱动为该同步事件分配的同步寄存器的标识Reg0-m。

S902、第一处理器通过调用第二API，向第二处理器发送第二同步事件对应的等待任务。

第一处理器和第二处理器为同一个AI服务器内的处理器。例如，如图10所示，该第一处理器可以为AI服务器1中的CPU1，第二处理器可以为AI服务器1中的AI加速器NPU0。

S903、第二处理器接收第二同步事件对应的等待任务。

S904、第二处理器基于第二同步寄存器的值，确定第二同步事件是否发生。

可以理解的，上述步骤S902-S904的具体实现方式可以参考前述步骤S602-S604的具体实现方式，在此不再赘述。

S905、第一处理器通过调用第六API，获取第二同步寄存器的虚拟地址。

该第六API用于获取同步对象对应的寄存器的虚拟地址。例如，该第六API可以为NotifyGetAddr(notify，addr)，其中输入为同步对象notify，输出为同步对象notify对应的同步寄存器的虚拟地址。

例如，如图10所示，AI服务器间进行同步时，APP1通过调用NotifyGetAddr接口，将同步对象notifyK对应的同步寄存器Reg0-m的物理地址映射为APP1的虚拟地址(VirtualAddress，VA)，记为VA1。比如，APP1调用Runtime的NotifyGetAddr接口，传入同步对象notifyK，Runtime根据同步对象notifyK获取同步寄存器Reg0-m的标识，NPU驱动根据同步寄存器Reg0-m的标识，获取同步寄存器的物理地址，并将该物理地址映射出APP1的虚拟地址，NPU驱动将该虚拟地址返回给Runtime，Runtime将虚拟地址返回给APP，完成同步寄存器的虚拟地址映射流程。

可选的，本申请实施例对于将同步寄存器的物理地址映射为虚拟地址的具体实现方式并不进行限定，具体可以参考现有技术，在此不再赘述。

S906、第一处理器向第四处理器发送第二同步寄存器的虚拟地址。

第四处理器可以为AI服务器中的中央控制单元，例如，CPU。第四处理器包括第二CPU。

第一处理器和第四处理器为不同AI服务器中的处理器。可选的，第一处理器和第四处理器可以为不同AI服务器中的CPU。

例如，如图10所示，第一处理器可以为AI服务器1中的CPU1，第四处理器可以为AI服务器2中的CPU2，AI服务器1中的CPU1向AI服务器2中的CPU2发送同步对象notifyK对应的同步寄存器Reg0-m的虚拟地址VA1。

S907、第四处理器接收第二同步寄存器的虚拟地址。

S908、第四处理器向第五处理器发送第二同步事件对应的远程直接内存存取(Remote Direct Memory Access，RDMA)任务。

第二同步事件对应的RDMA任务用于指示第二同步事件已经发生，第二同步事件对应的RDMA任务中包括第二同步寄存器的虚拟地址。

该第四处理器和第五处理器为同一个AI服务器内的处理器，第四处理器可以为AI服务器内的CPU，第五处理器可以为AI服务器内的AI加速器(比如，NPU)。

例如，如图10所示，第四处理器为AI服务器2中的CPU2，第五处理器可以为AI服务器2中的NPU1。CPU2可以通过调用RDMAsend(VA1，1)，向NPU1下发RDMA任务。

可选的，第四处理器可以通过调用第八API，向第五处理器发送第二同步事件对应的RDMA任务。该第八API用于下发同步事件对应的RDMA任务。例如，第八API为RDMAsend(addr，1)，用于指示向虚拟地址addr写入第二数值1。

S909、第五处理器接收第二同步事件对应的RDMA任务。

S910、第五处理器基于第二同步寄存器的虚拟地址，通过RDMA装置将第二同步寄存器的值重置为第二数值。

由于第二同步事件已经发生，第五处理器可以基于第二同步事件对应的RDMA任务中的第二同步寄存器的虚拟地址，将该第二同步寄存器的值重置为第二数值，以使得第二同步寄存器的值与第二同步事件的发生状态相对应。

例如，结合图10所示，AI服务器2中的NPU1可以基于VA1将NPU0中的Reg0-m的值重置为1，从而NPU0的控制器可以立刻检查到Reg0-m的取值修改，NPU0的控制器结束等待，并将Reg0-m的值清零。

可以理解的，在本申请实施例中，NotifyWait和RDMAsend是一一对应的，第五处理器接收RDMAsend任务后，获知同步对象对应的同步事件发生，通过RDMA装置将该同步对象对应的同步寄存器的值重置为1。第二处理器接收等待任务后，读取该同步对象对应的同步寄存器的值，如果同步寄存器的值0，确定同步事件未发生，第二处理器将一直保持等待，直到第五处理器将该同步对象对应的同步寄存器的值置为1，第二处理器检查到同步寄存器的值为1，确定同步事件已经发生，那么第二处理器结束等待，并将该同步寄存器的值重置为0，以便该同步寄存器可以继续进行后续的其他同步操作。

需要说明的是，本申请实施例对于上述步骤S901-S910的先后执行顺序并不限定，图9仅是示例性说明。

本申请实施例的同步方法，对于AI服务器间的同步，同步开销仅是网络通讯的时间开销，没有其它额外开销，因此同步开销较小。而且本申请实施例提供了简单的API接口，和通用OS的semaphore接口类似，可以大大方便开发者使用AI加速器。

可选的，上述方法还可以包括步骤S911。

S911、第一处理器通过调用第七API，解除第二同步寄存器与第二同步事件的对应关系，并将第二同步寄存器的值重置为第一数值。

可以理解的，上述步骤S911的具体实现方式可以参考步骤S608，在此不再赘述。

本申请实施例提供的同步方法，通过在AI加速器中设置一组同步寄存器，每个寄存器都可以与一个同步对象对应，该寄存器的不同取值用于指示同步对象对应的同步事件是否发生。在AI加速器接收等待任务时，通过读取相应的同步寄存器的值，能够在同步事件未发生时保持等待，在同步事件已经发生时结束等待。在AI加速器接收到RDMA任务时，通过在虚拟地址对应的同步寄存器中写入数值，指示同步事件已经发生，从而能够使得需要进行同步的AI加速器准确的实现同步。而且该方案通过将同步寄存器的物理地址转换成虚拟地址，并通过RDMA在虚拟地址写入数值，能够实现不同节点(AI服务器)间的同步。而且提供了简单的API接口、同步开销较小，提升了AI训练的效率。

本申请实施例还提供一种芯片的同步方法，如图11所示，在本实施例中第二同步事件发生在AI服务器之间，该方法包括以下步骤：

S1101、第一处理器为第二同步事件创建第二同步对象。

S1102、第一处理器通过调用第二API，向第二处理器发送第二同步事件对应的等待任务。

S1103、第二处理器接收第二同步事件对应的等待任务。

S1104、第二处理器基于第二同步寄存器的值，确定第二同步事件是否发生。

S1105、第一处理器通过调用第六API，获取第二同步寄存器的虚拟地址。

S1106、第一处理器向第四处理器发送第二同步寄存器的虚拟地址。

S1107、第四处理器接收第二同步寄存器的虚拟地址。

可以理解的，上述步骤S1101-S1107的具体实现方式可以参考前述步骤的实现方式，在此不再赘述。

S1108、第四处理器基于第二同步寄存器的虚拟地址，通过RDMA装置将第二同步寄存器的值重置为第二数值。

示例性的，如图10所示，当第二同步事件发生在AI服务器1和AI服务器2之间时，AI服务器2的CPU2接收同步寄存器Reg0-m的虚拟地址VA1后，CPU2可以在第二同步事件发生时，直接通过RDMA装置将第二同步寄存器的值重置为第二数值，而不需要像图9所示的实施例由AI服务器2的CPU2向NPU1发送RDMA任务，再由NPU1通过RDMA装置将第二同步寄存器的值重置为第二数值。可以理解的，CPU2在第二同步事件发生时，通过RDMA装置将同步寄存器Reg0-m的值重置为1后，NPU0的控制器可以立刻检查到Reg0-m的取值修改，NPU0的控制器结束等待，并将Reg0-m的值清零，从而实现AI服务器间的准确同步。

需要说明的是，本申请实施例对于上述步骤S1101-S1108的先后执行顺序并不限定，图11仅是示例性说明。

可选的，上述方法还可以包括步骤S1109。

S1109、第一处理器通过调用第七API，解除第二同步寄存器与第二同步事件的对应关系，并将第二同步寄存器的值重置为第一数值。

可以理解的，上述步骤S1109的具体实现方式可以参考步骤S608，在此不再赘述。

本申请实施例提供的同步方法，通过在AI加速器中设置一组同步寄存器，每个寄存器都可以与一个同步对象对应，该寄存器的不同取值用于指示同步对象对应的同步事件是否发生。在AI加速器接收等待任务时，通过读取相应的同步寄存器的值，能够在同步事件未发生时保持等待，在同步事件已经发生时结束等待。处理器在同步事件发生时，直接基于同步寄存器的虚拟地址，对同步寄存器写入数值，指示同步事件已经发生，从而能够使得需要进行同步的AI服务器之间准确的实现同步。

需要说明的是，本申请实施例对于上述第一API至第八API具体属于哪个APP的API并不进行限定，实际应用中，每个APP可以根据自己的业务需求，调用上述一个或多个API，以实现一个AI加速器内、一个AI服务器内的不同AI加速器间，或AI服务器间的同步。

本申请实施例还提供一种芯片，该芯片包括上述第一处理器和接口电路，第一处理器用于通过接口电路与其它装置通信，以实现图3、图6、图8、图9或图11所示的同步方法。可选的，该芯片还可以包括存储器，该存储器用于存储计算机指令。

本申请实施例还提供一种芯片，该芯片包括上述第二处理器和接口电路，第二处理器用于通过接口电路与其它装置通信，以实现图3、图6、图8、图9或图11所示的同步方法。

本申请实施例还提供一种芯片，该芯片包括上述第三处理器和接口电路，第三处理器用于通过接口电路与其它装置通信，以实现图6或图8所示的同步方法。

本申请实施例还提供一种芯片，该芯片包括上述第四处理器和接口电路，第四处理器用于通过接口电路与其它装置通信，以实现图9或图11所示的同步方法。

本申请实施例还提供一种芯片，该芯片包括上述第五处理器和接口电路，第五处理器用于通过接口电路与其它装置通信，以实现图11所示的同步方法。

本申请实施例还提供一种AI服务器，该AI服务器包括上述第一处理器、第二处理器，以及接口电路，该第一处理器和第二处理器通过接口电路通信，以实现图3、图6、图8、图9或图11所示的同步方法。

本申请实施例还提供一种AI服务器，该AI服务器包括上述第一处理器、第二处理器、第三处理器，以及接口电路，该第一处理器、第二处理器以及第三处理器通过接口电路通信，以实现图6或图8所示的同步方法。

本申请实施例还提供一种AI服务器，该AI服务器包括上述第四处理器、第五处理器，以及接口电路，该第四处理器和第五处理器通过接口电路通信，以实现图9所示的同步方法。

本申请实施例提供一种AI集群，该AI集群包括多个AI服务器，该AI服务器包括CPU和一个或多个AI加速器，CPU可以包括上述第一处理器，AI加速器可以包括上述第二处理器或第三处理器中的至少一种。

本申请实施例提供一种AI集群，该AI集群包括多个AI服务器，该AI服务器包括CPU和一个或多个AI加速器，CPU可以包括上述第四处理器，AI加速器可以包括上述第五处理器。

本申请实施例提供一种通信系统，该通信系统包括上述AI加速器、上述AI服务器，或上述AI集群中的至少一种。

本申请实施例提供一种应用程序接口API，该API部署在处理器中，该API用于为同步事件创建同步对象。可选的，该API可以为NotifyCreat(deviceID，notify)，其中，输入deviceID为AI加速器的ID，输出notify为同步对象。

本申请实施例提供一种应用程序接口API，该API部署在处理器中，该API用于下发同步事件对应的等待任务。可选的，该API可以为NotifyWait(notify，stream)接口，该接口用于在stream等待同步对象对应的同步事件发生。

本申请实施例提供一种应用程序接口API，该API部署在处理器中，该API用于下发同步事件对应的记录任务。可选的，该API可以为NotifyRecord(notify，stream)接口，该接口用于在stream设置同步对象对应的同步事件发生。

本申请实施例提供一种应用程序接口API，该API部署在处理器中，该API用于设置同步对象的全局名称。可选的，该API可以为IpcSetNotifyName(notify，name)，用于设置同步对象notify的全局名称。

本申请实施例提供一种应用程序接口API，该API部署在处理器中，该API用于打开同步对象。可选的，该API可以为IpcOpenNotify(notify，name)，用于根据同步对象notify的全局名称name，打开同步对象。

本申请实施例提供一种应用程序接口API，该API部署在处理器中，该API用于获取同步对象对应的寄存器的虚拟地址。可选的，该API可以为NotifyGetAddr(notify，addr)，其中输入为同步对象notify，输出为同步对象notify对应的同步寄存器的虚拟地址。

本申请实施例提供一种应用程序接口API，该API部署在处理器中，该API用于释放同步寄存器。可选的，该API可以为NotifyDestroy(notify)，该接口可以用于销毁同步对象notify，释放同步对象对应的同步寄存器。

本申请实施例提供一种应用程序接口API，该API部署在处理器中，该API用于下发同步事件对应的RDMA任务。可选的，该API可以为RDMAsend(addr，1)，用于指示向虚拟地址addr写入第二数值1。

本申请实施例还提供一种计算机可读存储介质，该计算机可读存储介质中存储有计算机程序代码，当上述处理器执行该计算机程序代码时，电子设备执行图3、图6、图8、图9或图11所示的同步方法。

本申请实施例还提供了一种计算机程序产品，当该计算机程序产品在计算机上运行时，使得计算机执行图3、图6、图8、图9或图11所示的同步方法。

结合本申请公开内容所描述的方法或者算法的步骤可以硬件的方式来实现，也可以是由处理器执行软件指令的方式来实现。软件指令可以由相应的软件模块组成，软件模块可以被存放于随机存取存储器(random access memory，RAM)、闪存、可擦除可编程只读存储器(erasable programmable ROM，EPROM)、电可擦可编程只读存储器(electricallyEPROM，EEPROM)、寄存器、硬盘、移动硬盘、只读光盘(CD-ROM)或者本领域熟知的任何其它形式的存储介质中。一种示例性的存储介质耦合至处理器，从而使处理器能够从该存储介质读取信息，且可向该存储介质写入信息。当然，存储介质也可以是处理器的组成部分。处理器和存储介质可以位于ASIC中。另外，该ASIC可以位于核心网接口设备中。当然，处理器和存储介质也可以作为分立组件存在于核心网接口设备中。

本领域技术人员应该可以意识到，在上述一个或多个示例中，本发明所描述的功能可以用硬件、软件、固件或它们的任意组合来实现。当使用软件实现时，可以将这些功能存储在计算机可读介质中或者作为计算机可读介质上的一个或多个指令或代码进行传输。计算机可读介质包括计算机存储介质和通信介质，其中通信介质包括便于从一个地方向另一个地方传送计算机程序的任何介质。存储介质可以是通用或专用计算机能够存取的任何可用介质。

以上所述的具体实施方式，对本发明的目的、技术方案和有益效果进行了进一步详细说明，所应理解的是，以上所述仅为本发明的具体实施方式而已，并不用于限定本发明的保护范围，凡在本发明的技术方案的基础之上，所做的任何修改、等同替换、改进等，均应包括在本发明的保护范围之内。

Claims (27)

1.一种同步方法，其特征在于，所述方法包括：

第一处理器为第一同步事件创建第一同步对象；所述第一同步对象中包括第一同步寄存器的标识，所述第一同步寄存器的值包括第一数值或第二数值，所述第一数值用于指示所述第一同步事件未发生，所述第二数值用于指示所述第一同步事件已经发生；所述第一处理器包括第一中央处理器CPU；

所述第一处理器通过调用第二API，向第二处理器发送所述第一同步事件对应的等待任务；所述第一同步事件对应的等待任务用于等待所述第一同步事件发生，所述第一同步事件对应的等待任务包括第一队列标识，以及所述第一同步寄存器的标识；所述第一队列标识为所述等待任务所在的队列的标识；所述第二处理器接收所述第一同步事件对应的等待任务；

所述第二处理器基于所述第一同步寄存器的值，确定所述第一同步事件是否发生；所述第二处理器包括第一NPU，所述第一同步事件为发生在所述第一NPU内的同步事件，或者，发生在所述第一NPU与其他NPU之间的同步事件，所述第二处理器为等待所述第一同步事件发生的处理器，且包括多个同步寄存器，所述第一同步寄存器为所述多个同步寄器中为所述第一同步事件分配的寄存器。

2.根据权利要求1所述的方法，其特征在于，所述第一处理器为所述第一同步事件创建第一同步对象，包括：

所述第一处理器通过调用第一应用程序接口API，在所述第二处理器包括的多个同步寄存器中为所述第一同步事件分配所述第一同步寄存器，并在所述第一同步对象中保存所述第一同步寄存器的标识。

3.根据权利要求1所述的方法，其特征在于，所述第二处理器基于所述第一同步寄存器的值，确定所述第一同步事件是否发生，包括：

在所述第一同步寄存器的值为所述第一数值的情况下，所述第二处理器确定所述第一同步事件未发生，所述第二处理器继续等待所述第一同步事件发生，直至所述第一同步寄存器的值为所述第二数值，所述第二处理器确定所述第一同步事件已经发生，所述第二处理器将所述第一同步寄存器的值重置为所述第一数值。

4.根据权利要求1所述的方法，其特征在于，所述第二处理器基于所述第一同步寄存器的值，确定所述第一同步事件是否发生，还包括：

在所述第一同步寄存器的值为所述第二数值的情况下，所述第二处理器确定所述第一同步事件已经发生，所述第二处理器将所述第一同步寄存器的值重置为所述第一数值。

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

所述第一处理器通过调用第三API，向所述第二处理器发送所述第一同步事件对应的记录任务；所述第一同步事件对应的记录任务用于指示所述第一同步事件已经发生，所述第一同步事件对应的记录任务中包括第二队列标识，以及所述第一同步寄存器的标识，所述第二队列标识为所述第一同步事件对应的记录任务所在的队列的标识；

所述第二处理器接收所述第一同步事件对应的记录任务，并基于所述第一同步寄存器的标识，将所述第一同步寄存器的值重置为所述第二数值。

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

所述第一处理器通过调用第三API，向第三处理器发送所述第一同步事件对应的记录任务；所述第一同步事件对应的记录任务用于指示所述第一同步事件已经发生，所述第一同步事件对应的记录任务中包括第二队列标识，以及所述第一同步寄存器的标识，所述第二队列标识为所述第一同步事件对应的记录任务所在的队列的标识；所述第三处理器包括第二NPU；

所述第三处理器接收所述第一同步事件对应的记录任务，并基于所述第一同步寄存器的标识，将所述第一同步寄存器的值重置为所述第二数值。

7.根据权利要求1所述的方法，其特征在于，若所述第一同步事件为进程间的同步事件，所述方法还包括：

所述第一处理器通过调用第一应用程序的第四API，将所述第一同步对象的名称设置为预设名称；

所述第一处理器通过调用第二应用程序的第五API，获取所述预设名称对应的所述第一同步寄存器的标识。

8.根据权利要求7所述的方法，其特征在于，所述第一同步事件为所述第一应用程序和所述第二应用程序之间的同步事件，所述预设名称为所述第一应用程序和所述第二应用程序预先约定的名称。

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

所述第一处理器为第二同步事件创建第二同步对象，所述第二同步对象中包括第二同步寄存器的标识；所述第一处理器通过调用第六API，获取所述第二同步寄存器的虚拟地址；所述第二同步寄存器为第二同步事件对应的寄存器，所述第二同步寄存器的不同值用于指示所述第二同步事件是否发生；

所述第一处理器向第四处理器发送所述第二同步寄存器的虚拟地址；所述第一处理器和所述第四处理器为不同AI服务器中的处理器，所述第四处理器包括第二CPU；所述第二同步事件为发生在不同AI服务器之间的同步事件。

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

所述第一处理器通过调用第七API，解除所述第一同步寄存器与所述第一同步事件的对应关系，并将所述第一同步寄存器的值重置为所述第一数值；所述第七API用于释放所述第一同步寄存器。

11.根据权利要求1所述的方法，其特征在于，所述第一同步寄存器的物理地址采用全局编址方式编址。

12.一种同步方法，其特征在于，所述方法包括：

第四处理器接收来自第一处理器的第二同步寄存器的虚拟地址；所述第二同步寄存器为第二同步事件对应的寄存器，所述第二同步寄存器的值包括第一数值或第二数值，所述第一数值用于指示所述第二同步事件未发生，所述第二数值用于指示所述第二同步事件已经发生；所述第一处理器和所述第四处理器为不同AI服务器中的处理器；所述第一处理器包括第一中央处理器CPU，所述第四处理器包括第二CPU；

所述第四处理器通过向第五处理器发送第二同步事件对应的远程直接内存存取RDMA任务；所述第二同步事件对应的RDMA任务用于指示所述第二同步事件已经发生，所述第二同步事件对应的RDMA任务中包括所述第二同步寄存器的虚拟地址；所述第五处理器包括第三NPU；

所述第五处理器接收所述第二同步事件对应的RDMA任务，并基于所述第二同步寄存器的虚拟地址，通过RDMA装置将所述第二同步寄存器的值重置为所述第二数值。

13.一种同步方法，其特征在于，所述方法包括：

第四处理器接收来自第一处理器的第二同步寄存器的虚拟地址，所述第二同步寄存器为第二同步事件对应的寄存器，所述第二同步寄存器的值包括第一数值或第二数值，所述第一数值用于指示所述第二同步事件未发生，所述第二数值用于指示所述第二同步事件已经发生；所述第一处理器和所述第四处理器为不同AI服务器中的处理器，所述第一处理器和所述第二同步寄存器位于同一个AI服务器中；所述第一处理器包括第一中央处理器CPU，所述第四处理器包括第二CPU；所述第二同步事件为发生在不同AI服务器之间的同步事件；

所述第四处理器基于所述第二同步寄存器的虚拟地址，通过远程直接内存存取RDMA装置将所述第二同步寄存器的值重置为所述第二数值。

14.一种同步装置，其特征在于，所述同步装置包括第二处理器，所述第二处理器包括多个同步寄存器，每个所述同步寄存器用于与一个同步事件相对应，每个所述同步寄存器的值包括第一数值或第二数值，所述第一数值用于指示所述同步寄存器对应的同步事件未发生，所述第二数值用于指示所述同步寄存器对应的同步事件已经发生；所述第二处理器包括第一NPU，第一同步事件为发生在所述第一NPU内的同步事件，或者，发生在所述第一NPU与其他NPU之间的同步事件；

第一处理器，用于通过为所述第一同步事件创建第一同步对象；所述第一同步对象中包括第一同步寄存器的标识；所述第一同步寄存器的不同值用于指示所述第一同步事件是否发生；所述第一处理器包括第一中央处理器CPU；

所述第一处理器，还用于通过调用第二API，向所述第二处理器发送所述第一同步事件对应的等待任务；所述第一同步事件对应的等待任务用于等待所述第一同步事件发生，所述第一同步事件对应的等待任务包括第一队列标识，以及所述第一同步寄存器的标识；所述第一队列标识为所述等待任务所在的队列的标识；所述第二处理器，还用于接收所述第一同步事件对应的等待任务；

所述第二处理器，还用于基于所述第一同步寄存器的值，确定所述第一同步事件是否发生，所述第二处理器为等待所述第一同步事件发生的处理器，且包括多个同步寄存器，所述第一同步寄存器为所述多个同步寄器中为所述第一同步事件分配的寄存器。

15.根据权利要求14所述的装置，其特征在于，所述第一处理器，具体用于通过调用第一应用程序接口API，在所述第二处理器包括的所述多个同步寄存器中为所述第一同步事件分配所述第一同步寄存器，并在所述第一同步对象中保存所述第一同步寄存器的标识。

16.根据权利要求14所述的装置，其特征在于，所述第二处理器，具体用于在所述第一同步寄存器的值为所述第一数值的情况下，确定所述第一同步事件未发生，所述第二处理器继续等待所述第一同步事件发生，直至所述第一同步寄存器的值为所述第二数值，所述第二处理器确定所述第一同步事件已经发生，将所述第一同步寄存器的值重置为所述第一数值。

17.根据权利要求14所述的装置，其特征在于，所述第二处理器，具体还用于在所述第一同步寄存器的值为所述第二数值的情况下，确定所述第一同步事件已经发生，将所述第一同步寄存器的值重置为所述第一数值。

18.根据权利要求14所述的装置，其特征在于，

所述第一处理器，还用于通过调用第三API，向所述第二处理器发送所述第一同步事件对应的记录任务；所述第一同步事件对应的记录任务用于指示所述第一同步事件已经发生，所述第一同步事件对应的记录任务中包括第二队列标识，以及所述第一同步寄存器的标识，所述第二队列标识为所述第一同步事件对应的记录任务所在的队列的标识；

所述第二处理器，还用于接收所述第一同步事件对应的记录任务，并基于所述第一同步寄存器的标识，将所述第一同步寄存器的值重置为所述第二数值。

19.根据权利要求14所述的装置，其特征在于，所述同步装置还包括第三处理器，所述第三处理器包括第二NPU；

所述第一处理器，还用于通过调用第三API，向所述第三处理器发送所述第一同步事件对应的记录任务；所述第一同步事件对应的记录任务用于指示所述第一同步事件已经发生，所述第一同步事件对应的记录任务中包括第二队列标识，以及所述第一同步寄存器的标识，所述第二队列标识为所述第一同步事件对应的记录任务所在的队列的标识；

所述第三处理器，用于接收所述第一同步事件对应的记录任务，并基于所述第一同步寄存器的标识，将所述第一同步寄存器的值重置为所述第二数值。

20.根据权利要求14所述的装置，其特征在于，若所述第一同步事件为进程间的同步事件；

所述第一处理器，还用于通过调用第一应用程序的第四API，将所述第一同步对象的名称设置为预设名称；

所述第一处理器，还用于通过调用第二应用程序的第五API，获取所述预设名称对应的所述第一同步寄存器的标识。

21.根据权利要求20所述的装置，其特征在于，所述第一同步事件为所述第一应用程序和所述第二应用程序之间的同步事件，所述预设名称为所述第一应用程序和所述第二应用程序预先约定的名称。

22.根据权利要求14所述的装置，其特征在于，

所述第一处理器，还用于为第二同步事件创建第二同步对象，所述第二同步对象中包括第二同步寄存器的标识；还用于通过调用第六API，获取所述第二同步寄存器的虚拟地址；所述第二同步寄存器为第二同步事件对应的寄存器，所述第二同步寄存器的不同值用于指示所述第二同步事件是否发生；

所述第一处理器，还用于向第四处理器发送所述第二同步寄存器的虚拟地址；所述第一处理器和所述第四处理器为不同AI服务器中的处理器，所述第四处理器包括第二CPU；所述第二同步事件为发生在不同AI服务器之间的同步事件。

23.根据权利要求14所述的装置，其特征在于，所述第一处理器，还用于通过调用第七API，解除所述第一同步寄存器与所述第一同步事件的对应关系，并将所述第一同步寄存器的值重置为所述第一数值；所述第七API用于释放所述第一同步寄存器。

24.根据权利要求14所述的装置，其特征在于，所述第一同步寄存器的物理地址采用全局编址方式编址。

25.一种同步装置，其特征在于，所述同步装置包括第四处理器和第五处理器；

第四处理器，用于接收来自第一处理器的第二同步寄存器的虚拟地址；所述第二同步寄存器为第二同步事件对应的寄存器，所述第二同步寄存器的值包括第一数值或第二数值，所述第一数值用于指示所述第二同步事件未发生，所述第二数值用于指示所述第二同步事件已经发生；所述第一处理器和所述第四处理器为不同AI服务器中的处理器；所述第一处理器包括第一中央处理器CPU，所述第四处理器包括第二CPU；

所述第四处理器，还用于向所述第五处理器发送第二同步事件对应的远程直接内存存取RDMA任务；所述第二同步事件对应的RDMA任务用于指示所述第二同步事件已经发生，所述第二同步事件对应的RDMA任务中包括所述第二同步寄存器的虚拟地址；所述第五处理器包括第三NPU；

所述第五处理器，用于接收所述第二同步事件对应的RDMA任务，并基于所述第二同步寄存器的虚拟地址，通过RDMA装置将所述第二同步寄存器的值重置为所述第二数值。

26.一种同步装置，其特征在于，所述同步装置包括第四处理器；

所述第四处理器，用于接收来自第一处理器的第二同步寄存器的虚拟地址，所述第二同步寄存器为第二同步事件对应的寄存器，所述第二同步寄存器的值包括第一数值或第二数值，所述第一数值用于指示所述第二同步事件未发生，所述第二数值用于指示所述第二同步事件已经发生；所述第一处理器和所述第四处理器为不同AI服务器中的处理器；所述第一处理器包括第一中央处理器CPU，所述第四处理器包括第二CPU；所述第二同步事件为发生在不同AI服务器之间的同步事件；

所述第四处理器，还用于基于所述第二同步寄存器的虚拟地址，通过远程直接内存存取RDMA装置将所述第二同步寄存器的值重置为所述第二数值。

27.一种电子设备，其特征在于，所述电子设备包括存储器，以及如权利要求14-26中任一项所述的同步装置。

Images