A GPU collective communication method, system, device, medium and product

Abstract

This invention discloses a GPU ensemble communication method, system, device, medium, and product. The method first maps ensemble communication interfaces from different GPU device manufacturers to a unified standard API interface based on GPU device manufacturer information, generating an interface mapping relationship. When responding to a ensemble communication request initiated by a user calling the API interface, the method translates the ensemble communication request into a corresponding manufacturer's ensemble communication interface request based on the GPU type used by the user and the interface mapping relationship, thereby invoking the corresponding manufacturer's ensemble communication interface to perform ensemble communication operations. Using this invention can reduce the development and maintenance complexity of multi-GPU ensemble communication systems and improve the overall performance and efficiency of distributed training of AI models.

Description

Technical Field

[0001] This invention relates to the field of computer technology, and in particular to a GPU ensemble communication method, system, device, medium, and product. Background Technology

[0002] GPUs (Graphics Processing Units) are hardware devices specifically designed to accelerate graphics rendering and computation, widely used in gaming, artificial intelligence, and scientific computing. In distributed training scenarios for AI models, the GPU, as the core computing power, directly determines the efficiency and stability of model training through its collective communication capabilities. This is because distributed training requires collective communication operations among multiple GPUs, including parameter synchronization, data transfer, and task coordination, to achieve global computational consistency. However, current GPUs from different manufacturers are equipped with dedicated collective communication libraries and corresponding proprietary communication interfaces, and there are significant differences in the communication library protocols, interface specifications, and underlying driver adaptation logic among these manufacturers.

[0003] This necessitates the development of separate adaptation code for upper-layer AI learning frameworks (such as PyTorch, TensorFlow, and Caffe) for GPUs from different manufacturers. This not only increases the repetitive workload for developers and reduces development efficiency, but also results in poor system compatibility and high porting costs. Furthermore, when adding new models or manufacturers of GPUs, the upper-layer communication logic needs to be reconstructed, leading to insufficient scalability and severely restricting the flexible deployment and efficient iteration of distributed training systems for AI models. Summary of the Invention

[0004] The purpose of this invention is to provide a GPU ensemble communication method, system, device, medium, and product, which reduces the complexity of developing and maintaining multi-GPU ensemble communication systems and improves the overall performance of distributed training of AI models.

[0005] To achieve the above objectives, the present invention provides a GPU ensemble communication method, comprising: Based on the GPU device manufacturer information, the communication interfaces of different manufacturers are mapped to a unified standard API interface to generate interface mapping relationships; In response to a user's call to the API interface to initiate a collection communication request, the collection communication request is translated into a collection communication interface request of the corresponding vendor based on the GPU type used by the user and the interface mapping relationship, so as to call the collection communication interface of the corresponding vendor to perform collection communication operations.

[0006] Optionally, the step of mapping the aggregated communication interfaces of different manufacturers to a unified standard API interface based on the manufacturer information of the GPU device, and generating an interface mapping relationship, includes: Obtain the manufacturer information of the GPU device, and load the corresponding manufacturer's collection communication library based on the manufacturer information; Extract the corresponding vendor's aggregate communication interface from the loaded aggregate communication library; Based on preset interface function matching rules, a correspondence is established between the vendor's aggregated communication interface and the unified standard API interface, generating an interface mapping relationship.

[0007] Optionally, translating the aggregated communication request into a corresponding vendor's aggregated communication interface request based on the GPU type used by the user and the interface mapping relationship, so as to invoke the corresponding vendor's aggregated communication interface to perform aggregated communication operations, includes: Determine the corresponding interface conversion logic based on the type of GPU used by the user; Based on the interface mapping relationship, the aggregate communication request is translated into the aggregate communication interface request of the corresponding vendor through the interface conversion logic; Based on the aforementioned aggregate communication interface request, the corresponding vendor's aggregate communication interface is invoked to perform aggregate communication operations.

[0008] Optionally, the GPU ensemble communication method further includes: Record log data during the collection communication process; The log data includes at least one of the following: collection communication request parameters, execution process events, error reports, and performance data.

[0009] Optionally, the unified standard API interface is constructed based on a standard interface template defined by a preset abstract class. The standard interface template includes the input parameter format, output result specification, calling process, and error handling rules corresponding to the required collection communication functions.

[0010] To achieve the above objectives, the present invention also provides a GPU ensemble communication system, including multiple adapter modules and at least one scheduling module, wherein the adapter modules include an initialization unit and an ensemble communication unit; The initialization unit is used to map the collective communication interfaces of different manufacturers to a unified standard API interface based on GPU manufacturer information, and to establish an interface mapping relationship. The scheduling module is used to forward the collection communication request initiated by the user through the unified standard API interface to the corresponding adapter module according to the type of GPU used by the user. The aggregate communication unit is used to receive aggregate communication requests, and translate the aggregate communication requests into aggregate communication interface requests of the corresponding vendor according to the GPU type used by the user and the interface mapping relationship, so as to call the aggregate communication interface of the corresponding vendor to perform aggregate communication operations.

[0011] Optionally, the initialization unit is used for: Obtain the manufacturer information of the GPU device, and load the corresponding manufacturer's collection communication library based on the manufacturer information; Extract the corresponding vendor's aggregate communication interface from the loaded aggregate communication library; Based on preset interface function matching rules, a correspondence is established between the vendor's aggregated communication interface and the unified standard API interface, generating an interface mapping relationship.

[0012] To achieve the above objectives, the present invention also provides a GPU ensemble communication device, comprising: a processor, a memory, and a computer program stored in the memory and configured to be executed by the processor, wherein the processor executes the computer program to implement the GPU ensemble communication method as described above.

[0013] To achieve the above objectives, the present invention also provides a computer-readable storage medium storing a computer program, wherein, when the computer program is executed, it controls the device where the computer-readable storage medium is located to execute the GPU ensemble communication method described in any of the above claims.

[0014] To achieve the above objectives, the present invention also provides a computer program product, including a computer program / instructions that, when executed by a processor, implement the GPU ensemble communication method as described in any of the above claims.

[0015] Compared to existing technologies, the GPU ensemble communication method, system, device, medium, and product provided in this invention can shield the interface differences between GPUs from multiple manufacturers at the underlying level, eliminating the need for upper-layer AI frameworks to develop separate adaptation code for different manufacturers' GPUs, thus reducing repetitive development workload and system porting costs. Furthermore, it can directly call the manufacturer's native ensemble communication interface, fully reusing the manufacturer's underlying performance optimization logic for the communication library to ensure communication efficiency in distributed training. When adding a new GPU manufacturer or model, only the corresponding interface mapping relationship needs to be supplemented to complete the adaptation, without reconstructing the upper-layer communication logic, effectively improving the system's compatibility and scalability, thereby enhancing the flexible deployment and efficient iteration of the AI ​​model distributed training system. Attached Figure Description

[0016] To more clearly illustrate the technical solution of the present invention, the accompanying drawings used in the embodiments will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0017] Figure 1This is a flowchart illustrating a GPU ensemble communication method provided in an embodiment of the present invention; Figure 2 This is a structural block diagram of a GPU ensemble communication system provided in an embodiment of the present invention; Figure 3 This is a structural block diagram of a GPU-based communication device provided in an embodiment of the present invention. Detailed Implementation

[0018] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0019] See Figure 1 , Figure 1 This is a flowchart illustrating a GPU ensemble communication method provided in an embodiment of the present invention, the GPU ensemble communication method comprising steps S1 to S2: Step S1: Based on the GPU device manufacturer information, map the communication interfaces of different manufacturers to a unified standard API interface to generate an interface mapping relationship; In one optional embodiment, step S1 includes: Obtain the manufacturer information of the GPU device, and load the corresponding manufacturer's collection communication library based on the manufacturer information; Extract the corresponding vendor's aggregate communication interface from the loaded aggregate communication library; Based on preset interface function matching rules, a correspondence is established between the vendor's aggregated communication interface and the unified standard API interface, generating an interface mapping relationship.

[0020] In one optional embodiment, the unified standard API interface is constructed based on a standard interface template defined by a preset abstract class; wherein, the standard interface template includes the input parameter format, output result specification, calling process and error handling rules corresponding to the required collection communication function.

[0021] For example, when the AI ​​model distributed training system starts, it first obtains the information of the GPU device manufacturers currently deployed, and loads the corresponding collection communication library according to the manufacturer information. These libraries contain the corresponding manufacturer's optimization algorithms and hardware support.

[0022] For example, if the manufacturer information returned by some GPU devices is "A" and that of others is "B", for GPUs with manufacturer information "A", their dedicated ensemble communication library 'a' is loaded, and the core ensemble communication interface corresponding to the distributed training parameters of the model is extracted from the loaded library 'a'; for GPUs with manufacturer information "B", their dedicated ensemble communication library 'b' is loaded, and the corresponding core ensemble communication interface is extracted, and so on.

[0023] Subsequently, based on the unified standard interface template defined in the preset abstract class baseInterface (including templates that correspond one-to-one with the core functions of collection communication, such as collection communication interfaces), according to the preset rule of "functional matching", the collection communication interfaces extracted from library a and library b are all established with the unified standard API interface to ensure that collection communication operations can be performed by calling the unified API interface in the future. Finally, these correspondences are stored in the global pointer table to generate a complete interface mapping relationship.

[0024] Through the above steps, this invention can ensure the accuracy and operability of the mapping between the collective communication interfaces of GPUs from different manufacturers and the unified standard API interface. By loading the manufacturer's native collective communication library and extracting the interface, the underlying performance optimization of the communication function can be guaranteed. At the same time, the unified function matching rules avoid interface mapping confusion, so that the upper-layer AI framework does not need to develop adaptation code separately for GPUs from different manufacturers. This can significantly reduce the adaptation workload and development cost for developers. When adding GPUs from other manufacturers in the future, it is only necessary to load their exclusive collective communication library and extract the interface according to the same rules to complete the mapping. There is no need to modify the core logic, which can improve the system's compatibility, portability and scalability.

[0025] Step S2: In response to the user's call to the API interface to initiate a collection communication request, according to the GPU type used by the user and the interface mapping relationship, call the corresponding manufacturer's collection communication interface to perform collection communication operation.

[0026] In one optional embodiment, translating the aggregated communication request into a corresponding vendor's aggregated communication interface request based on the GPU type used by the user and the interface mapping relationship, and then invoking the corresponding vendor's aggregated communication interface to perform aggregated communication operations, includes: Determine the corresponding interface conversion logic based on the type of GPU used by the user; Based on the interface mapping relationship, the aggregate communication request is translated into the aggregate communication interface request of the corresponding vendor through the interface conversion logic; Based on the aforementioned aggregate communication interface request, the corresponding vendor's aggregate communication interface is invoked to perform aggregate communication operations.

[0027] For example, when the upper-layer AI framework calls the unified standard API interface to initiate a ensemble communication request related to model training, it identifies the GPU type currently executing the task. If the current GPU type is "A" GPU, it then determines the corresponding interface conversion logic based on the GPU type, such as "converting the general parameters in the request into the specific parameter format required by a certain interface in library 'a'". Subsequently, according to the preset interface mapping relationship, the ensemble communication request initiated by the unified standard API interface is translated into a specific interface request specific to library 'a' through the above interface conversion logic. Finally, based on this specific interface request, the corresponding ensemble communication interface is called to perform model training operations between multiple GPUs. The same logic applies if the current GPU type is "B" GPU.

[0028] This invention, by configuring dedicated interface conversion logic for different types of GPUs and combining it with preset interface mapping relationships to translate requests, can effectively avoid request conversion errors caused by differences in the parameter formats and calling specifications of communication interfaces from different manufacturers. This ensures the accuracy of communication operations and improves the communication efficiency of distributed training of AI models. At the same time, for GPUs from new manufacturers, only the corresponding interface conversion logic needs to be added and the interface mapping relationship updated, without modifying the core request processing flow. This enhances system compatibility and scalability while reducing the development and maintenance costs of adapting to GPUs from multiple manufacturers.

[0029] In summary, the GPU ensemble communication method provided by this invention first maps the private ensemble communication interfaces of different GPU device manufacturers to a standard API interface based on GPU device manufacturer information, generating an interface mapping relationship. Then, when responding to a user's ensemble communication request, the method accurately translates the request of the unified API interface into the private interface request of the corresponding manufacturer based on the GPU type used by the user and the preset interface mapping relationship, and calls and executes it. This method can shield the interface differences of GPUs from multiple manufacturers at the underlying level, eliminating the need for the upper-layer AI framework to develop adaptation code separately for GPUs from different manufacturers, thus reducing repetitive development workload and system porting costs. Furthermore, it can directly call the manufacturer's native ensemble communication interface, fully reusing the manufacturer's underlying performance optimization logic for the communication library to ensure the communication efficiency of distributed training. At the same time, when adding a new GPU manufacturer or model, only the corresponding interface mapping relationship needs to be added to complete the adaptation, without the need to reconstruct the upper-layer communication logic, effectively improving the system's compatibility and scalability, thereby enhancing the flexible deployment and efficient iteration of the AI ​​model distributed training system.

[0030] In one optional embodiment, the GPU ensemble communication method further includes: Record log data during the collection communication process; The log data includes at least one of the following: collection communication request parameters, execution process events, error reports, and performance data.

[0031] It is worth noting that the log data, including detailed information recorded during the collective communication process in the embodiments of the present invention, is crucial for system debugging and performance optimization. Developers can use the recorded log data to review the system's operation chain, quickly locate potential problems such as interface translation anomalies, vendor communication library call failures, and parameter matching errors, and analyze performance shortcomings such as the time consumption distribution and rate bottlenecks of GPU communication from different vendors. This provides data support for optimizing interface conversion logic and scheduling strategies, thereby improving the efficiency of collective communication through targeted adjustments, and ultimately enhancing the distributed training efficiency of AI models.

[0032] See Figure 3 , Figure 3 This is a structural block diagram of a GPU collective communication system provided in an embodiment of the present invention. The GPU collective communication system includes multiple adapter modules 221~22n and at least one scheduling module 21. Each adapter module includes an initialization unit and a collective communication unit. The initialization unit is used to map the collective communication interfaces of different manufacturers to a unified standard API interface based on GPU manufacturer information, and to establish an interface mapping relationship. The scheduling module is used to forward the collection communication request initiated by the user through the unified standard API interface to the corresponding adapter module according to the type of GPU used by the user. The aggregate communication unit is used to receive aggregate communication requests, and translate the aggregate communication requests into aggregate communication interface requests of the corresponding vendor according to the GPU type used by the user and the interface mapping relationship, so as to call the aggregate communication interface of the corresponding vendor to perform aggregate communication operations.

[0033] It should be noted that the GPU collective communication system provided in this embodiment of the invention is essentially a multi-vendor GPU compatible collective communication middleware system (CMCCL), in which each module and unit works together to achieve efficient communication adaptation between the upper-layer AI framework and the lower-layer multi-vendor GPU hardware.

[0034] Upstream, CMCCL interfaces with various AI training frameworks. These frameworks do not need to develop dedicated communication adaptation code for different GPU manufacturers. They only need to initiate a collection communication request through the unified standard API interface provided by CMCCL to achieve core requirements such as model parameter synchronization and distributed computing task coordination. Downstream, CMCCL is tightly integrated with the drivers and native collection communication libraries of GPUs from various manufacturers, providing underlying support for the efficient execution of communication operations.

[0035] In one alternative embodiment, the initialization unit is configured to: Obtain the manufacturer information of the GPU device, and load the corresponding manufacturer's collection communication library based on the manufacturer information; Extract the corresponding vendor's aggregate communication interface from the loaded aggregate communication library; Based on preset interface function matching rules, a correspondence is established between the vendor's aggregated communication interface and the unified standard API interface, generating an interface mapping relationship.

[0036] In one alternative embodiment, the aggregated communication unit is configured to: Determine the corresponding interface conversion logic based on the type of GPU used by the user; Based on the interface mapping relationship, the aggregate communication request is translated into the aggregate communication interface request of the corresponding vendor through the interface conversion logic; Based on the aforementioned aggregate communication interface request, the corresponding vendor's aggregate communication interface is invoked to perform aggregate communication operations.

[0037] For example, the adapter module is responsible for seamlessly integrating the collective communication libraries of various vendors into CMCCL and ensuring that user requests can be correctly mapped to the specific vendor's collective communication library.

[0038] The initialization unit performs initialization operations during system startup, with the core objective of achieving unified adaptation of multi-vendor communication interfaces. First, it obtains the GPU device's vendor information through the underlying hardware detection interface. Based on this information, it loads the corresponding GPU driver and the vendor's native aggregated communication library. After the library is loaded and initialized, it extracts various vendor-specific aggregated communication interfaces from this library. Simultaneously, it predefines an abstract class `baseInterface`, which contains a series of standard interface templates for core aggregated communication functions supporting distributed training of AI models. These templates form the core framework of the unified standard API interface. Then, based on preset interface function matching rules, it matches the extracted vendor-specific aggregated communication interfaces one-to-one with the unified standard API interfaces defined in the `baseInterface` abstract class. Finally, during program startup, it instantiates the aggregated communication library object corresponding to the current GPU vendor and registers this object and the interface matching relationship in the global pointer table, generating a complete interface mapping relationship and persisting it. This completes the unified adaptation initialization of multi-vendor communication interfaces.

[0039] The scheduling module serves as the core communication bridge between the upper-layer AI framework and downstream vendor-specific adapter modules. Its core function is to achieve unified reception and forwarding of user aggregated communication requests. When the upper-layer AI framework initiates aggregated communication requests such as model parameter synchronization and distributed task coordination through the CMCCL unified standard API interface during distributed training tasks, the scheduling module first receives the request. Then, it obtains and identifies the GPU device type currently executing the task in real time. Based on the pre-established "GPU type - vendor-specific adapter module" association, it forwards the aggregated communication request to the dedicated adapter module that uniquely matches the current GPU vendor. This bridges the gap for subsequent request translation and calls to the vendor's native interface, without requiring the upper-layer AI framework to concern itself with the differentiated adaptation logic of downstream multi-vendor hardware.

[0040] Furthermore, after receiving the request forwarded by the scheduling module, the aggregate communication unit retrieves the interface mapping relationship generated by the initialization unit according to the current GPU type. Through the preset interface conversion logic, it translates the general request parameters of the unified standard API interface into the special parameter format of the corresponding vendor's aggregate communication interface, generates a vendor-specific aggregate communication interface request, and then calls the vendor's native aggregate communication interface. Relying on the hardware acceleration capabilities provided by the underlying GPU driver, it efficiently executes the aggregate communication operation and finally feeds back the execution result to the upstream AI framework.

[0041] In an optional embodiment, the GPU ensemble communication system further includes a logging module for: Record log data during the collection communication process; The log data includes at least one of the following: collection communication request parameters, execution process events, error reports, and performance data.

[0042] It should be noted that the GPU ensemble communication system provided in this embodiment of the invention is used to execute all the process steps of the GPU ensemble communication method in the above embodiment. The working principles and beneficial effects of the two are one-to-one, so they will not be described again.

[0043] See Figure 3 , Figure 3 This is a structural block diagram of a GPU co-communication device provided in an embodiment of the present invention. The GPU co-communication device includes a processor 31, a memory 32, and a computer program stored in the memory 32 and executable on the processor 31. When the processor 31 executes the computer program, it implements the steps described in the various GPU co-communication method embodiments above.

[0044] For example, the computer program may be divided into one or more modules / units, which are stored in the memory 32 and executed by the processor 31 to complete the present invention. The one or more modules / units may be a series of computer program instruction segments capable of performing a specific function, which describe the execution process of the computer program in the GPU aggregation communication device.

[0045] The GPU ensemble communication device may include, but is not limited to, processor 31 and memory 32. Those skilled in the art will understand that the schematic diagram is merely an example of a GPU ensemble communication device and does not constitute a limitation on the GPU ensemble communication device. It may include more or fewer components than illustrated, or combine certain components, or different components. For example, the GPU ensemble communication device may also include input / output devices, network access devices, buses, etc.

[0046] The processor 31 can be a Central Processing Unit (CPU), or other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. The general-purpose processor can be a microprocessor or any conventional processor. The processor 31 is the control center of the GPU ensemble communication device, connecting various parts of the entire GPU ensemble communication device through various interfaces and lines.

[0047] The memory 32 can be used to store the computer programs and / or modules. The processor 31 implements various functions of the GPU-based communication device by running or executing the computer programs and / or modules stored in the memory 32 and calling the data stored in the memory 32. The memory 32 may mainly include a program storage area and a data storage area. The program storage area may store the operating system, at least one application program required for a function (such as sound playback function, image playback function, etc.), etc.; the data storage area may store data created according to the use of the mobile phone (such as audio data, phonebook, etc.). In addition, the memory 32 may include high-speed random access memory, and may also include non-volatile memory, such as hard disk, memory, plug-in hard disk, smart media card (SMC), secure digital card (SD) card, flash card, at least one disk storage device, flash memory device, or other volatile solid-state storage device.

[0048] Wherein, if the modules / units integrated by the GPU communication device are implemented as software functional units and sold or used as independent products, they can be stored in a computer-readable storage medium. Based on this understanding, all or part of the processes in the methods of the above embodiments of the present invention can also be implemented by a computer program instructing related hardware. The computer program can be stored in a computer-readable storage medium, and when the computer program is executed by the processor 31, it can implement the steps of the various method embodiments described above. Wherein, the computer program includes computer program code, which can be in the form of source code, object code, executable file, or some intermediate form, etc. The computer-readable medium can include: any entity or device capable of carrying the computer program code, recording medium, USB flash drive, portable hard drive, magnetic disk, optical disk, computer memory, read-only memory (ROM), random access memory (RAM), electrical carrier signal, telecommunication signal, and software distribution medium, etc.

[0049] Furthermore, embodiments of the present invention also provide a computer program product, including a computer program / instruction, which, when executed by a processor, implements the GPU aggregation communication method as described in any of the above embodiments.

[0050] The above description represents the preferred embodiments of the present invention. It should be noted that those skilled in the art can make various improvements and modifications without departing from the principles of the present invention, and these improvements and modifications are also considered to be within the scope of protection of the present invention.

Claims

1. A GPU ensemble communication method, characterized in that, include: Based on the GPU device manufacturer information, the communication interfaces of different manufacturers are mapped to a unified standard API interface to generate interface mapping relationships; In response to a user's call to the API interface to initiate a collection communication request, the collection communication request is translated into a collection communication interface request of the corresponding vendor based on the GPU type used by the user and the interface mapping relationship, so as to call the collection communication interface of the corresponding vendor to perform collection communication operations.

2. The GPU ensemble communication method as described in claim 1, characterized in that, The step of mapping the aggregated communication interfaces of different manufacturers to a unified standard API interface based on the GPU device manufacturer information, and generating interface mapping relationships, includes: Obtain the manufacturer information of the GPU device, and load the corresponding manufacturer's collection communication library based on the manufacturer information; Extract the corresponding vendor's aggregate communication interface from the loaded aggregate communication library; Based on preset interface function matching rules, a correspondence is established between the vendor's aggregated communication interface and the unified standard API interface, generating an interface mapping relationship.

3. The GPU ensemble communication method as described in claim 2, characterized in that, The step of translating the aggregated communication request into a corresponding vendor's aggregated communication interface request based on the GPU type used by the user and the interface mapping relationship, and then invoking the corresponding vendor's aggregated communication interface to perform aggregated communication operations, includes: Determine the corresponding interface conversion logic based on the type of GPU used by the user; Based on the interface mapping relationship, the aggregate communication request is translated into the aggregate communication interface request of the corresponding vendor through the interface conversion logic; Based on the aforementioned aggregate communication interface request, the corresponding vendor's aggregate communication interface is invoked to perform aggregate communication operations.

4. The GPU ensemble communication method as described in claim 1, characterized in that, Also includes: Record log data during the collection communication process; The log data includes at least one of the following: collection communication request parameters, execution process events, error reports, and performance data.

5. The GPU ensemble communication method as described in claim 1, characterized in that, The unified standard API interface is built based on a standard interface template defined by a pre-defined abstract class. The standard interface template includes the input parameter format, output result specification, calling process, and error handling rules corresponding to the required collection communication functions.

6. A GPU ensemble communication system, characterized in that, It includes multiple adapter modules and at least one scheduling module, wherein the adapter module includes an initialization unit and a collection communication unit; The initialization unit is used to map the collective communication interfaces of different manufacturers to a unified standard API interface based on GPU manufacturer information, and to establish an interface mapping relationship. The scheduling module is used to forward the collection communication request initiated by the user through the unified standard API interface to the corresponding adapter module according to the type of GPU used by the user. The aggregate communication unit is used to receive aggregate communication requests, and translate the aggregate communication requests into aggregate communication interface requests of the corresponding vendor according to the GPU type used by the user and the interface mapping relationship, so as to call the aggregate communication interface of the corresponding vendor to perform aggregate communication operations.

7. The GPU ensemble communication system as described in claim 6, characterized in that, The initialization unit is used for: Obtain the manufacturer information of the GPU device, and load the corresponding manufacturer's collection communication library based on the manufacturer information; Extract the corresponding vendor's aggregate communication interface from the loaded aggregate communication library; Based on preset interface function matching rules, a correspondence is established between the vendor's aggregated communication interface and the unified standard API interface, generating an interface mapping relationship.

8. A GPU-based communication device, characterized in that, include: A processor, a memory, and a computer program stored in the memory and configured to be executed by the processor, wherein the processor, when executing the computer program, implements the GPU ensemble communication method as described in any one of claims 1 to 5.

9. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores a computer program, wherein, when the computer program is executed, it controls the device where the computer-readable storage medium is located to perform the GPU ensemble communication method as described in any one of claims 1 to 5.

10. A computer program product comprising a computer program / instructions, characterized in that, When the computer program / instruction is executed by the processor, it implements the GPU ensemble communication method as described in any one of claims 1 to 5.

Images