High-performance Linpack benchmarking methods, heterogeneous computing systems, and storage media
By employing a non-recursive algorithm to process data block decomposition and updates in parallel within a heterogeneous computing system, the problem of serial dependency between CPU and GPU in heterogeneous computing systems is solved, enabling more efficient HPL test execution and improving computing performance.
Patent Information
- Application Number
- CN202311778848.2
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- Filing Date
- 2023-12-22
- Publication Date
- 2026-11-10
- Estimated Expiration
- 2043-12-22
AI Technical Summary
In heterogeneous computing systems, the CPU's decomposition and processing of panel data and the GPU's updating of the tail matrix in existing technologies have a serial dependency, resulting in low execution efficiency of HPL testing and failure to fully utilize the accelerator's computing resources.
By employing a non-recursive algorithm in a heterogeneous computing system, the central processing unit (CPU) performs triangular decomposition on the data blocks during the panel decomposition process, dividing the data blocks into first and second data blocks. The data size of the first data block is less than or equal to that of the second data block. The accelerator is used to update the first data block, obtaining the update result in advance for the next sub-decomposition process. At the same time, the accelerator updates the second data block, realizing parallel operation of the CPU and the accelerator.
It improves the coordination efficiency between the CPU and the accelerator, optimizes the overall execution efficiency of the HPL test, makes full use of the accelerator's computing resources, reduces waiting time, and improves computing performance.
Smart Images

Figure CN117743056B_ABST
Abstract
Description
Technical Field
[0001] Embodiments of this disclosure relate to a high-performance Linpack benchmarking method, a heterogeneous computing system, and a storage medium. Background Technology
[0002] High-performance computing (HPC) typically refers to computing using many processors, which can be integrated together or deployed in a distributed manner. Currently, the mainstream architectures for high-performance computing include homogeneous and heterogeneous architectures. Homogeneous architecture usually refers to a cluster where all computing nodes consist of a central processing unit (CPU), while heterogeneous architecture combines CPUs with other types of computing resources, such as CPUs and accelerators. Common heterogeneous architectures include CPU+GPU (Graphics Processing Unit), CPU+MIC (Many Integrated Core), and CPU+FPGA (Field Programmable Gate Array). Heterogeneous architectures offer advantages such as good scalability and high utilization of computing resources.
[0003] After the cluster is established, its performance can be tested, for example, using the High Performance Linpack (HPL) benchmark. HPL is an industry-recognized benchmark method for evaluating the performance of high-performance computers. It is part of the LINPACK numerical linear algebra library and is used to solve systems of linear algebraic equations, particularly linear least squares problems. HPL tests are commonly used to evaluate the performance of large-scale computer systems such as supercomputers and cluster computers, especially in scientific computing, engineering computing, and other fields requiring significant computational resources. Summary of the Invention
[0004] This disclosure provides at least one embodiment of a high-performance Linpack benchmarking method for a heterogeneous computing system including a central processing unit (CPU) and an accelerator. The method includes: during panel decomposition of panel data to be decomposed into a matrix, obtaining a data block to be decomposed in the current sub-decomposition process of the panel decomposition process; performing triangular decomposition on the data block to be decomposed in the current sub-decomposition process using the CPU to obtain a decomposition result; performing block processing on the tail matrix to be updated corresponding to the data block to be decomposed to obtain a first data block and a second data block, wherein the data size of the first data block is less than or equal to the data size of the second data block; performing update processing on the first data block using the accelerator to obtain a first update result, and performing update processing on the second data block to obtain a second update result, wherein the first update result includes the data block to be decomposed in the next sub-decomposition process, and the first update result is used in the next sub-decomposition process earlier than the second update result, so that the update processing of the second data block in the current sub-decomposition process by the accelerator and the triangular decomposition processing of the data block to be decomposed in the next sub-decomposition process by the CPU can be performed in parallel.
[0005] For example, in the method provided in at least one embodiment of this disclosure, the panel decomposition process is implemented only by a non-recursive algorithm.
[0006] For example, in the method provided in at least one embodiment of this disclosure, the non-recursive algorithm includes loop processing.
[0007] For example, in a method provided in at least one embodiment of this disclosure, the accelerator includes a graphics processor.
[0008] For example, in the method provided in at least one embodiment of this disclosure, the size of the data block to be decomposed and the size of the first data block are both the minimum decomposition block size.
[0009] For example, at least one embodiment of this disclosure provides a method that further includes: the central processing unit interacting with the accelerator via data exchange.
[0010] The data interaction between the central processing unit (CPU) and the accelerator includes: after the accelerator completes the update processing of the first data block, the accelerator sends the first update result to the CPU, and the CPU receives the first update result; and after the accelerator completes the update processing of the second data block, the accelerator sends the second update result to the CPU, and the CPU receives the second update result, wherein the first update result is sent to the CPU earlier than the second update result.
[0011] For example, at least one embodiment of the method provided in this disclosure further includes: the central processing unit performing row swapping processing based on the decomposition result.
[0012] For example, in a method provided in at least one embodiment of this disclosure, the central processing unit interacts with the accelerator by: after performing the row swapping process based on the decomposition result, the central processing unit sends the row swapped data to the accelerator, and the accelerator receives the row swapped data.
[0013] For example, at least one embodiment of the method provided in this disclosure further includes: obtaining the tail matrix to be updated corresponding to the data block to be decomposed based on the data after the row swapping process.
[0014] For example, in a method provided in at least one embodiment of this disclosure, the step of updating the first data block through an accelerator to obtain a first update result and updating the second data block to obtain a second update result includes: updating the first data block through a first computing stream of the accelerator to obtain a first update result; and updating the second data block through a second computing stream of the accelerator to obtain a second update result, wherein the first computing stream updates the second data block together with the second computing stream after completing the update processing of the first data block.
[0015] For example, at least one embodiment of the method provided in this disclosure further includes: performing row swapping processing on some data during the previous round of update; and starting the current round of panel decomposition process in advance after the row swapping processing and update processing are completed.
[0016] For example, at least one embodiment of the method provided in this disclosure further includes: during the period after the matrix multiplication process in the previous round of update has ended and before the current round of panel decomposition process has ended, the accelerator performs matrix multiplication processing in the current round of update on the data that has already completed row swapping processing.
[0017] For example, in the method provided in at least one embodiment of this disclosure, the accelerator has a higher priority for the computational flow in the current round panel decomposition process than for the computational flow in the update process.
[0018] At least one embodiment of this disclosure also provides a heterogeneous computing system, including a central processing unit (CPU) and an accelerator. In a panel decomposition process of performing triangular decomposition on panel data to be decomposed in a matrix, the CPU is configured to acquire a data block to be decomposed in the current sub-decomposition process of the panel decomposition process and perform triangular decomposition on the data block to be decomposed in the current sub-decomposition process to obtain a decomposition result. The accelerator is configured to perform block processing on the tail matrix to be updated corresponding to the data block to be decomposed to obtain a first data block and a second data block, and to perform update processing on the first data block to obtain a first update result, and to perform update processing on the second data block to obtain a second update result. The data size of the first data block is less than or equal to the data size of the second data block. The first update result includes the data block to be decomposed in the next sub-decomposition process, and the first update result is used in the next sub-decomposition process earlier than the second update result, so that the update processing of the second data block in the current sub-decomposition process by the accelerator and the triangular decomposition processing of the data block to be decomposed in the next sub-decomposition process by the CPU can be performed in parallel.
[0019] For example, at least one embodiment of the heterogeneous computing system provided in this disclosure further includes: a communication network configured to realize data interaction between the central processing unit and the accelerator, wherein after the accelerator completes the update processing of the first data block, the accelerator sends the first update result to the central processing unit through the communication network, and the central processing unit receives the first update result through the communication network; and after the accelerator completes the update processing of the second data block, the accelerator sends the second update result to the central processing unit through the communication network, and the central processing unit receives the second update result through the communication network, wherein the first update result is sent to the central processing unit earlier than the second update result.
[0020] For example, at least one embodiment of the heterogeneous computing system provided in this disclosure further includes: a memory storing executable instructions, which are executed by the central processing unit and the accelerator to perform triangular decomposition processing on the panel data to be decomposed of the matrix.
[0021] At least one embodiment of this disclosure also provides a non-transitory computer-readable storage medium, wherein the non-transitory computer-readable storage medium stores computer-executable instructions that, when executed by a processor, implement the method described according to any embodiment of this disclosure. Attached Figure Description
[0022] To more clearly illustrate the technical solutions of the embodiments of this disclosure, the accompanying drawings of the embodiments will be briefly described below. Obviously, the drawings described below only relate to some embodiments of this disclosure and are not intended to limit this disclosure.
[0023] Figure 1 This is a schematic diagram of a block matrix LU algorithm;
[0024] Figure 2 A flowchart illustrating a high-performance Linpack benchmarking method provided in at least one embodiment of this disclosure;
[0025] Figure 3 A schematic diagram illustrating a block processing and update process provided in at least one embodiment of this disclosure;
[0026] Figure 4 A schematic diagram illustrating a panel decomposition process provided for at least one embodiment of this disclosure;
[0027] Figure 5 A flowchart illustrating an exemplary high-performance Linpack benchmarking method provided for at least one embodiment of this disclosure;
[0028] Figure 6 A comparison diagram of panel decomposition processes implemented using recursive and non-recursive algorithms, provided for at least one embodiment of this disclosure;
[0029] Figure 7 A schematic diagram illustrating the collaborative utilization of accelerator computing resources in an update process and a panel decomposition process, provided for at least one embodiment of this disclosure; and
[0030] Figure 8 This is a schematic block diagram of a heterogeneous computing system provided for at least one embodiment of the present disclosure. Detailed Implementation
[0031] To make the objectives, technical solutions, and advantages of the embodiments of this disclosure clearer, the technical solutions of the embodiments of this disclosure will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some, not all, of the embodiments of this disclosure. All other embodiments obtained by those skilled in the art based on the described embodiments of this disclosure without creative effort are within the scope of protection of this disclosure.
[0032] Unless otherwise defined, the technical or scientific terms used in this disclosure shall have the ordinary meaning understood by one of ordinary skill in the art to which this disclosure pertains. The terms “first,” “second,” and similar terms used in this disclosure do not indicate any order, quantity, or importance, but are merely used to distinguish different components. Terms such as “comprising” or “including” mean that the element or object preceding the word encompasses the element or object listed following the word and its equivalents, without excluding other elements or objects. Terms such as “connected” or “linked” are not limited to physical or mechanical connections, but can include electrical connections, whether direct or indirect. Terms such as “upper,” “lower,” “left,” and “right” are used only to indicate relative positional relationships, which may change accordingly when the absolute position of the described objects changes. It should be understood that the various steps described in the method embodiments of this disclosure may be performed in different orders and / or in parallel. Furthermore, method embodiments may include additional steps and / or omit the steps shown. The scope of this disclosure is not limited in this respect.
[0033] The present disclosure will now be described through several specific embodiments. To keep the following description of the embodiments of the present disclosure clear and concise, detailed descriptions of known functions and known components may be omitted. When any component of an embodiment of the present disclosure appears in more than one drawing, the component is represented by the same or similar reference numerals in each drawing.
[0034] The HPL test measures the performance of a computer system by performing computationally intensive numerical computations on a large system of linear algebraic equations. For example, the HPL test evaluates a computer's floating-point performance and memory bandwidth by solving a very large system of linear equations. In the HPL test, performance is typically measured in floating-point operations per second (FLOPS), which is the number of floating-point operations the computer can perform per second. The reported FLOPS is the basis for the internationally renowned TOP500 supercomputer ranking. HPL provides a parallel implementation of partially pivoted LU decomposition for solving large-scale dense linear equation systems, with the primary goal of solving an Nth-order linear equation system. Ax=b The solution is to perform LU decomposition on the N×(N+1)[A | b] coefficient matrix by selecting local column pivots. LU decomposition, also known as triangular decomposition, is a type of matrix decomposition that can decompose a matrix into the product of a unit lower triangular matrix L and an upper triangular matrix U, hence the name LU decomposition.
[0035] For example, the coefficient matrix [A | b] can be decomposed into the following form:
[0036] [ A | b ] = [ [ LU ] | y ]
[0037] Since the transformations made by the lower triangular matrix L are gradually applied to b during the decomposition process, the solution x of the final system of equations can be transformed into solving a system of linear equations with the upper triangular matrix U as the coefficient matrix. U x = y .
[0038] For example, HPL solves Nth-order linear equations using an iterative method. Ax=b. The solution process for each iteration includes the following steps:
[0039] (1) Decomposition (pfact): The processes that have the current NB column data work together to perform the decomposition operation to obtain the decomposition result and row exchange information IPIV.
[0040] (2) Broadcast: Each process broadcasts its decomposition results and line exchange information IPIV in the line direction.
[0041] (3) Row swap: After receiving broadcast data, other column processes swap within their own column based on the row swap information IPIV.
[0042] (4) Update: All processes perform update processes such as upper triangular matrix update (DTRSM) and matrix multiplication update (DGEMM).
[0043] The process of performing LU decomposition on the data in column NB (hereinafter referred to as "decomposition") is called panel decomposition. Panel decomposition is a specific decomposition method for large matrices, commonly used in high-performance computing, and can be accelerated through parallel computing. Panel decomposition divides the matrix into multiple sub-blocks, which can then be further processed using LU decomposition methods. Therefore, panel decomposition can be viewed as a parallelized version of LU decomposition.
[0044] Figure 1 This is a schematic diagram of a block matrix LU algorithm. For example... Figure 1 As shown in subgraph (a), a large n×n matrix is divided into multiple data blocks A. 1,1 A 2,1 A 1,2 A 2,2 A 1,1 and A 2,1 This represents panel data. A 1,1 It is a matrix block of size NB×NB, A 2,1It is a matrix panel with a width of NB, so the panel data is a long, thin matrix with NB columns.
[0045] After decomposing the panel data, the decomposition result L can be obtained. 1,1 U 1,1 L 2,1 And IPIV. For example Figure 1 As shown in subgraph (b), L 1,1 It is the decomposed lower triangular matrix, U 1,1 It is the decomposed upper triangular matrix, L 2,1 It is a matrix slice in the column direction, U 1,2 TR is the row-oriented matrix slice, which is the trailing matrix, referring to the portion of the matrix solved in HPL that has not yet undergone panel decomposition. IPIV is the pivot index, an integer array that records the row swapping operations performed during matrix decomposition to select the largest pivot and move it to the current processing position.
[0046] The mathematical formula for each iteration can be expressed as follows:
[0047]
[0048]
[0049]
[0050] Formula (1) represents the panel decomposition of the data in column NB, and formula (2) represents the solution of the matrix slice U in the row direction. 1,2 Formula (3) represents the update of the tail matrix.
[0051] In modern computing, due to the ever-increasing demands for computing performance and energy efficiency, heterogeneous systems have become a common computing architecture, widely used in high-performance computing, artificial intelligence, big data analytics, and other applications. A heterogeneous system refers to a computing system composed of different types of processors, accelerators, storage devices, and interconnect networks. These different types of devices can include CPUs, GPUs, FPGAs, and ASICs (Application Specific Integrated Circuits). Heterogeneous systems can fully leverage the advantages of different devices to improve system performance and efficiency. In heterogeneous systems, different types of processors and accelerators can work in parallel, thereby achieving higher computing performance. For example, GPUs are typically good at parallel computing, while CPUs are better suited for handling sequential tasks; therefore, combining them can better utilize their respective strengths.
[0052] Currently, Heterogeneous Programming Processing (HPL) based on heterogeneous systems typically uses the CPU to perform panel data decomposition and the GPU to perform tail matrix updates, thereby improving HPL efficiency. This is because the computational scale of each step in the panel decomposition process is relatively small, and frequent calls are not conducive to acceleration using accelerators. Therefore, panel decomposition is suitable for execution on the CPU, while tail matrix updates involve matrix multiplication operations, which account for the majority of the computation, and are therefore suitable for execution on the GPU.
[0053] HPL is typically solved iteratively using the NB column as the iteration step, such as Figure 3 As shown in subgraph (a), each iteration operation proceeds from the top left to the bottom right, with each NB column as the unit. Only after one NB column has undergone LU decomposition according to steps (1) to (4) can the next NB column continue to undergo LU decomposition according to steps (1) to (4). Figure 3 As shown in sub-graph (a), the solid-color shaded areas represent parts that have already been decomposed; the dotted shaded areas represent the current round of panel decomposition. In the current round of panel decomposition, the panel data to be decomposed, Panel-1, is decomposed, and then the decomposition results are broadcast and row swapped. Next, the tail matrix in the lower right corner of Panel-1 is updated. The vertical shaded areas represent the next round of panel decomposition. In the next round of panel decomposition, the next panel data to be decomposed, Panel-2, is decomposed, and then the decomposition results are broadcast and row swapped. Next, the tail matrix in the lower right corner of Panel-2 is updated. This process continues until all data in the matrix has undergone panel decomposition and update. As HPL runs, the amount of panel data to be decomposed decreases linearly.
[0054] The panel decomposition process is a critical path in the entire High-Performance Processing (HPL) cycle. Each iteration of HPL requires panel decomposition before proceeding with subsequent row swapping and update processing based on the decomposition results. Since the update process depends on the decomposition results and the CPU and accelerators (e.g., GPUs) in heterogeneous computing systems need to interact with each other, the GPU's update of the tail matrix must wait until the CPU has completed the panel decomposition process. Similarly, the next iteration's panel decomposition process depends on the previous iteration's update results; that is, the CPU's decomposition of the panel data in the next iteration must wait until the GPU has completed the update process for all data in the previous iteration. For example, after the CPU completes the panel decomposition process, it must first send the decomposition results (after row swapping) to the GPU. The GPU then updates all tail matrix data corresponding to the panel data based on these results and sends the updated results back to the CPU before it can begin decomposing the panel data in the next iteration. Therefore, optimizing the panel decomposition process in heterogeneous computing systems is of great significance.
[0055] This disclosure provides at least one embodiment of a high-performance Linpack benchmarking method for a heterogeneous computing system including a central processing unit (CPU) and an accelerator. The method includes: during panel decomposition of panel data to be decomposed into a matrix, obtaining a data block to be decomposed in the current sub-decomposition process; performing triangular decomposition on the data block to be decomposed in the current sub-decomposition process using the CPU to obtain a decomposition result; dividing the tail matrix to be updated corresponding to the data block to be decomposed into blocks to obtain a first data block and a second data block, wherein the data size of the first data block is less than or equal to the data size of the second data block; updating the first data block using the accelerator to obtain a first update result, and updating the second data block to obtain a second update result. The first update result includes the data block to be decomposed in the next sub-decomposition process, and the first update result is used in the next sub-decomposition process earlier than the second update result, so that the accelerator's update of the second data block in the current sub-decomposition process and the CPU's triangular decomposition of the data block to be decomposed in the next sub-decomposition process can be performed in parallel.
[0056] At least one embodiment of this disclosure also provides a heterogeneous computing system and a computer-readable storage medium.
[0057] The high-performance Linpack benchmarking method, heterogeneous computing system, and computer-readable storage medium of the above embodiments of this disclosure can divide the data after panel decomposition into blocks, update the first data block and the second data block respectively, and use the first update result obtained after updating the first data block in advance for the next panel decomposition, thereby providing more favorable conditions for the complex collaborative process of CPU and accelerator. Through the coordination of the update process and the panel decomposition process, the computing resources of the accelerator are fully utilized, and the execution of panel decomposition as a critical path is advanced, which improves the collaborative efficiency between CPU and accelerator and is conducive to improving the overall execution efficiency of HPL.
[0058] For example, in embodiments of this disclosure, accelerators include, but are not limited to, graphics processors, digital signal processors, mathematical coprocessors, neural network accelerators, accelerator cards, and other accelerators suitable for performing matrix multiplication calculations. For instance, graphics processors (GPUs) have excellent performance in processing graphics and image-related calculations and are therefore often used as graphics accelerators in fields such as gaming, video editing, and scientific computing. Digital signal processors (DSPs) are typically used to process digital signals, such as audio and video, and have efficient data processing and computing capabilities, enabling them to support the solution of high-density computational tasks. Mathematical coprocessors are typically used to accelerate mathematical operations, such as vector processors and digital signal processors. Neural network accelerators are typically used to accelerate the training and inference of artificial neural networks, such as tensor processing units (TPUs). In embodiments of this disclosure, the number of accelerators can be one or more, and the accelerators can be any of the above-mentioned accelerators or a combination of multiple accelerators. They can include existing accelerators capable of performing floating-point operations, as well as new accelerators developed in the future. Embodiments of this disclosure do not limit the type and number of accelerators in heterogeneous computing systems. For ease of description, embodiments of this disclosure are described below using a GPU as an example.
[0059] Figure 2 A flowchart illustrating a high-performance Linpack benchmarking method provided for at least one embodiment of this disclosure. Figure 2 As shown, this high-performance Linpack benchmark testing method includes the following steps S100~S400.
[0060] Step S100: Obtain the data block to be decomposed in the current sub-decomposition process of the panel decomposition process.
[0061] Step S200: The central processing unit performs triangular decomposition processing on the data block to be decomposed in the current sub-decomposition process to obtain the decomposition result.
[0062] Step S300: Divide the tail matrix to be updated corresponding to the data block to be decomposed into blocks to obtain the first data block and the second data block. The data size of the first data block is less than or equal to the data size of the second data block.
[0063] Step S400: The first data block is updated by the accelerator to obtain a first update result, and the second data block is updated to obtain a second update result. The first update result includes the data block to be decomposed in the next sub-decomposition process, and the first update result is used in the next sub-decomposition process earlier than the second update result, so that the accelerator's update processing of the second data block in the current sub-decomposition process and the central processing unit's triangular decomposition processing of the data block to be decomposed in the next sub-decomposition process can be performed in parallel.
[0064] In the embodiments of this disclosure, similar to the panel decomposition process of decomposing panel data of size NB using an iterative method, the LU decomposition process of the sub-data blocks to be decomposed of size NBMIN can be performed using an iterative method. Each iteration operation is performed progressively from the top left to the bottom right, with NBMIN as the unit. For ease of understanding and description, the above steps S100~S400 can be regarded as sub-processes in any panel decomposition process of the matrix, such as... Figure 3 As shown in subplots (a) and (b), after determining the width NB of the panel data to be decomposed, an appropriate CPU decomposition width NBMIN can be selected as the width of the data block to be decomposed in the sub-decomposition process.
[0065] In some embodiments of this disclosure, in step S100, the data block to be decomposed in the current sub-decomposition process of the panel decomposition process is obtained. The size of the data block to be decomposed can be the minimum decomposition block size NBMIN. In embodiments of this disclosure, "the size of the data block to be decomposed" can be understood as the width of the matrix block (slender matrix piece) to be decomposed in any sub-decomposition process. Figure 3 As shown in subgraph (b), the width of the data block A to be decomposed is NBMIN.
[0066] In HPL, NB and NBMIN represent the size of the decomposition block and the size of the minimum decomposition block, respectively. NB is the block size of the matrix, which is typically determined by considering various factors such as the size of the computational nodes, the matrix size, and communication overhead. For example, when the node size is large, NB can be set smaller, and when the node size is small, NB can be set larger. A larger NB can improve computational parallelism but also increase communication overhead, so the value of NB can be chosen according to actual needs. Commonly used NB values include 384 or 256, and NB can have other values; this disclosure does not restrict the value of NB. NBMIN is the minimum block size of the matrix, used to specify the size of the smallest block in the matrix decomposition. For example, when the dimension of the matrix cannot be divided evenly by NB, the size of the last decomposition block may be smaller than NB; NBMIN specifies the size of this minimum block. In practice, NB is usually chosen to be a larger value to improve parallel performance, while NBMIN is chosen to be a smaller value to ensure that the size of the last block is not too small, thereby reducing communication overhead. NBMIN represents the CPU and GPU allocation balance threshold under different design algorithms, which can be determined based on different algorithm design experiments. For example, NBMIN can be 32, 64, or any other suitable value. It should be noted that in the embodiments of this disclosure, NBMIN can be determined based on the balance between the utilization of heterogeneous computing resources and communication overhead, and NBMIN should be divisible by NB.
[0067] For example, after obtaining the data block A to be decomposed in the current sub-decomposition process, step S200 can be executed: the central processing unit (CPU) performs triangular decomposition processing on the data block to be decomposed in the current sub-decomposition process to obtain the decomposition result. The calculation formula for the triangular decomposition processing of the data block to be decomposed in the current sub-decomposition process can refer to the formula (1) above. The decomposition result includes the upper triangular matrix, lower triangular matrix, column-direction matrix slices, row-direction matrix slices, and tail matrix to be updated after sub-decomposition. Figure 3 Data such as the shaded area of subgraph (b) in the image.
[0068] For example, the method provided in at least one embodiment of this disclosure further includes: a central processing unit (CPU) performing row swapping processing based on the decomposition results.
[0069] For example, after performing the decomposition process, the CPU can perform row swapping on at least a portion of the data based on the decomposition results. Here, "at least a portion of the data" can be half of the data that has already undergone row swapping, thus facilitating subsequent update processing in advance. The specific implementation of the row swapping process can be found in conventional implementations in this field, and will not be elaborated upon here.
[0070] For example, at least one embodiment of the method provided in this disclosure further includes: data interaction between the CPU and an accelerator (e.g., GPU). For example, after the CPU performs row swapping processing on the data based on the decomposition results, the CPU and GPU can interact to send the data after the CPU has performed the row swapping processing to the GPU, and the GPU receives the data after the row swapping processing.
[0071] For example, at least one embodiment of this disclosure provides a method that further includes: obtaining the tail matrix to be updated corresponding to the data block to be decomposed based on the data after row swapping. For example, the GPU can obtain the data after row swapping and determine the tail matrix to be updated corresponding to the data block A to be decomposed. Figure 3 In the current sub-decomposition process shown in subgraph (b), the tail matrix to be updated corresponding to the data block A to be decomposed is the shaded part in the figure.
[0072] For example, during step S300, the tail matrix to be updated corresponding to the data block A to be decomposed is divided into blocks to obtain a first data block and a second data block. The data size of the first data block is less than or equal to the data size of the second data block. In embodiments of this disclosure, the first data block includes at least the data block in the left NB column of the tail matrix to be updated. For example, as... Figure 3 As shown in subgraph (b), the data in the left NBMIN column of the tail matrix to be updated is divided into the first data block B1, and the remaining data in the tail matrix to be updated is divided into the second data block B2. For example, the width of the first data block B1 can be NBMIN, then the width of the second data block B2 is the width of the tail matrix to be updated minus NBMIN.
[0073] For example, when executing step S400, the first data block B1 is updated by the accelerator to obtain the first update result, and the second data block B2 is updated to obtain the second update result. The first update result includes the data block to be decomposed in the next sub-decomposition process.
[0074] For example, in some embodiments of this disclosure, the first update result is used in the next sub-decomposition process earlier than the second update result. For example, the accelerator can simultaneously update the first data block B1 and the second data block B2 to obtain the first update result and the second update result, or it can first update the first data block B1 to obtain the first update result first, and then update the second data block B2 to obtain the second update result, thereby ensuring that the first update result can be used in the next sub-decomposition process earlier than the second update result.
[0075] In the embodiments of this disclosure, it is necessary to ensure that the first update result is used in the next sub-decomposition process before the second update result because the first update result includes the data block to be decomposed in the next sub-decomposition process. If the first update result can be sent to the CPU earlier, then the CPU can perform the next sub-decomposition process in advance. That is, if the GPU has not finished updating all the data of the tail matrix to be updated, the CPU can perform LU decomposition processing on the data to be decomposed in the next sub-decomposition process in advance. This allows the accelerator's update processing of the second data block in the current sub-decomposition process and the CPU's triangular decomposition processing of the data block to be decomposed in the next sub-decomposition process to be performed in parallel.
[0076] For example, a GPU comprises multiple computational streams that can execute multiple kernel functions simultaneously. A kernel is a parallel computational function that runs on the GPU. Each kernel executes independently on the GPU and can be executed in parallel by multiple threads. It is typically used to perform relatively independent computational tasks, such as image processing, physics simulation, and numerical computation. A GPU can use different computational streams to simultaneously update the first data block B1 and the second data block B2; for example, it can execute the DGEMM function on both the first data block B1 and the second data block B2.
[0077] For example, in at least one example of the embodiments of this disclosure, step S300, which involves updating the first data block using an accelerator to obtain a first update result and updating the second data block to obtain a second update result, may include: updating the first data block using a first computing stream of the accelerator to obtain a first update result; and updating the second data block using a second computing stream of the accelerator to obtain a second update result, wherein the first computing stream updates the first data block together with the second computing stream after completing the update process for the first data block.
[0078] For example, when the first computation stream that is updating the first data block B1 becomes idle, the second data block B2 can be loaded immediately, so that the second computation stream can perform the update process on the second data block B2 together, thereby reducing the idle time of the GPU's computation stream and improving the utilization of computing resources.
[0079] For example, in at least one example of the embodiments of this disclosure, the central processing unit (CPU) and the accelerator interact with each other. A specific example may include: after the accelerator completes the update processing of a first data block, the accelerator sends the first update result to the CPU, and the CPU receives the first update result; and after the accelerator completes the update processing of a second data block, the accelerator sends the second update result to the CPU, and the CPU receives the second update result. The first update result is sent to the CPU before the second update result. This advances the execution of panel decomposition as the critical path, improves the collaborative efficiency between the CPU and the accelerator, and enhances the overall execution efficiency of the HPL.
[0080] Because developers have considerable freedom with HPL (Hardware Panel Layout), meaning that aside from the data generation pattern and basic algorithm cannot be changed, the algorithm implementation details can be freely improved by developers to fully leverage the architectural characteristics of different systems and achieve peak performance. Therefore, designing and developing more efficient HPL code is of great significance to the research, testing, and release of supercomputer systems. In the panel decomposition implementation of standard HPL, various decomposition methods are implemented recursively. Recursive methods can decompose complex problems into smaller, more manageable subproblems and can adapt to different matrix sizes and structures. Therefore, recursive methods can handle panel decomposition at different levels, are generally easier to understand and implement, and are thus widely used in HPL.
[0081] However, this approach limits the full collaborative parallelism between the CPU and accelerators (such as GPUs) in the panel decomposition process. For example, when using recursion for panel decomposition, a recursive function is typically written to handle the matrix decomposition process. This recursive function continuously calls itself to process sub-parts of the matrix until a basic condition or recursion termination condition is reached. Because the recursive function is called recursively, this means that the function continuously calls itself while processing subproblems. Therefore, during panel decomposition, at any given moment, the computational task is either in CPU mode or GPU kernel mode; the CPU and GPU cannot execute tasks in parallel simultaneously.
[0082] Therefore, in the method provided in at least one embodiment of this disclosure, the panel decomposition process is implemented only by a non-recursive algorithm. That is, the above steps S100 to S400 are implemented by a non-recursive algorithm.
[0083] As is well known to those skilled in the art, non-recursive algorithms do not require function calls to implement panel decomposition. Non-recursive algorithms typically use loops or iterations to handle matrix decomposition, rather than recursively calling functions. Implementing steps S100-S400 using a non-recursive algorithm allows the CPU and GPU to execute LU decomposition and update processes in parallel. Furthermore, using a non-recursive algorithm avoids additional function call overhead and memory overhead from recursive calls during matrix decomposition, improving the collaborative efficiency between the CPU and accelerator, and enhancing the overall execution efficiency of HPL.
[0084] Figure 4 This is a schematic diagram of a panel decomposition process provided for at least one embodiment of the present disclosure. Figure 5 A flowchart illustrating an exemplary high-performance Linpack benchmarking method provided for at least one embodiment of this disclosure. The following is in conjunction with... Figure 4 and Figure 5 A detailed explanation of the high-performance Linpack benchmark testing method is provided.
[0085] First, determine the width NB of the panel data to be decomposed based on the algorithm design requirements, and then select an appropriate decomposition width NBMIN for the data block to be decomposed. Next, rewrite the panel decomposition code to eliminate recursion, implementing HPL using a non-recursive algorithm.
[0086] Next, as Figure 5 As shown, step S501 is executed: The CPU processes the data block A to be decomposed in the current sub-decomposition process (for example, such as...). Figure 4 The first NBMIN column data (A-1) shown is decomposed.
[0087] Further, step S502 is executed: row swapping is performed on the remaining data based on the decomposition results. For example, row swapping is performed based on the decomposition results obtained after decomposing the data block A-1 to be decomposed.
[0088] Further, step S503 is executed: the CPU and GPU interact with each other. For example, the CPU sends the data after decomposing and row-swapping the data block A-1 to be decomposed to the GPU, and the GPU receives the data after row-swapping.
[0089] Then the loop continues. For example, in the first loop, step S504 is executed: the tail matrix to be updated corresponding to the data block A-1 to be decomposed is divided into blocks to obtain the first data block B1 (for example, as shown in the figure). Figure 4 As shown in B1-1) and the second data block B2 (e.g., as ... Figure 4 (As shown in B2-1). The width of the first data block B1-1 is, for example, NBMIN.
[0090] Further, step S505 is executed: the GPU updates the first data block B1 (e.g., B1-1) to obtain the first update result. For example... Figure 4 As shown, the first update result includes the data block A-2 to be decomposed in the next sub-decomposition process.
[0091] For example, while performing step S505, step S508 can be performed: the GPU updates the second data block B2 (e.g., B2-1) to obtain a second update result. For example, the first data block B1 and the second data block B2 can also be updated sequentially, as long as it is ensured that the first update result is used in the next sub-decomposition process before the second update result.
[0092] For example, after executing step S505, step S506 can be executed: the CPU and GPU interact with each other. For example, the GPU sends the first update result to the CPU, and the CPU receives the first update result.
[0093] Since the first data block B1-1 is updated first, the GPU may not have finished executing step S508 after step S506 is completed. In this case, step S507 can be executed on the CPU beforehand: the CPU decomposes the next data block A to be decomposed (for example, ...). Figure 4 (The NBMIN column data A-2 in the next sub-decomposition process).
[0094] For example, after executing step S508, step S509 can be executed: the CPU and GPU interact with each other. For example, the GPU sends the second update result to the CPU, and the CPU receives the second update result.
[0095] Furthermore, after the second data block B2-1 has also finished updating and completing data interaction on the GPU, step S510 is executed: row swapping is performed based on the decomposition result. For example, this decomposition result is the new decomposition result obtained by the CPU after decomposing the data block A-2 to be decomposed in the next sub-decomposition process.
[0096] Further, step S511 is executed: the CPU and GPU interact with each other.
[0097] Further, proceed to step S512: Determine whether the data decomposition of column NB is complete?
[0098] If yes, then complete the panel decomposition process; otherwise, jump to step S504 to perform block processing on the matrix to be updated in the next update process to obtain a new first data block B1-2 and a second data block B2-2. The width of the first data block B1-2 is, for example, NBMIN.
[0099] In the second loop, further, step S505 is executed: the GPU updates the first data block B1-2 to obtain a new first update result. For example, the new first update result includes the data block A-3 to be decomposed in the next sub-decomposition process (e.g., ...). Figure 4 The part corresponding to data block B1-2 in the middle.
[0100] For example, in step S508, the GPU updates the second data block B2-2 to obtain a new second update result.
[0101] For example, after executing step S505, step S506 can be executed: the CPU and GPU interact with each other. For example, the GPU sends the new first update result to the CPU, and the CPU receives the new first update result.
[0102] Since the first data block B1-2 is updated first, the GPU may not have finished executing step S508 after step S506 is completed. In this case, step S507 can be executed on the CPU in advance: the CPU decomposes the next data block A-3 to be decomposed.
[0103] For example, after executing step S508, step S509 can be executed: the CPU and GPU interact with each other. For example, the GPU sends the new second update result to the CPU, and the CPU receives the new second update result.
[0104] Furthermore, after the second data block B2-2 has also finished updating and completing data interaction on the GPU, step S510 is executed: row swapping is performed based on the decomposition result. For example, the decomposition result is the new decomposition result obtained by the CPU after decomposing the data block A-3 to be decomposed in the next sub-decomposition process.
[0105] Further, step S511 is executed: the CPU and GPU interact with each other.
[0106] ...
[0107] Repeat the above iterative process until the current round of panel decomposition is complete.
[0108] Figure 6 A comparison diagram showing the panel decomposition process implemented using recursive and non-recursive algorithms, provided for at least one embodiment of this disclosure. (See diagram for reference.) Figure 6As shown, when implementing HPL using a recursive algorithm, the CPU's decomposition processing and the GPU's update processing cannot be executed in parallel. However, when implementing HPL using a non-recursive algorithm and the method provided in the embodiments of this disclosure, after the CPU completes the decomposition processing of A-1, the GPU can divide the tail matrix to be updated into a first data block B1-1 and a second data block B2-1. Then, the update processing of the first data block B1-1 is performed first to obtain the first update result. The first update result includes the next data block to be decomposed, A-2, which can be sent to the CPU in advance, allowing the CPU to start the next decomposition processing earlier. That is, the GPU's update processing of the second data block B2-1 in the current sub-decomposition process and the CPU's triangular decomposition processing of the data block A-2 to be decomposed in the next sub-decomposition process can be performed in parallel. This fully utilizes the GPU's computing resources, advances the execution of panel decomposition as the critical path, improves the collaborative efficiency between the CPU and GPU, and is beneficial to improving the overall execution efficiency of HPL.
[0109] Furthermore, the entire panel decomposition process involves a large number of GPU kernels, making it difficult to fully utilize the GPU. To address this issue, at least one embodiment of this disclosure provides a method that further includes the following steps S500-S700.
[0110] Step S500: Perform row swapping on some data during the previous update process.
[0111] Step S600: After the row swapping and update processes are completed, start the panel decomposition process for the current round in advance.
[0112] Step S700: During the period between the completion of matrix multiplication processing in the previous round of update and the completion of panel decomposition process in the current round, the accelerator performs matrix multiplication processing in the current round of update on the data that has already completed row swapping processing.
[0113] For example, through the above steps S500~S700, the panel decomposition and update processes can be integrated and optimized on a heterogeneous system, allowing some irrelevant data in the update process to be processed in conjunction with the panel decomposition process, thereby making full use of computing resources.
[0114] It should be noted that before performing the above steps S500~S700, it is necessary to configure the GPU's computation kernel priority during panel decomposition to be higher than the DGEMM priority during the update process.
[0115] For example, in step S500, the previous round of update process can be initiated. For instance, a computing stream of the GPU executes the DGEMM function on the data blocks in the previous round of update process, while the CPU performs row swapping of some data.
[0116] Furthermore, in step S600, after the data exchange and minor update process is completed, the current round panel decomposition process can be started in advance.
[0117] Furthermore, in step S700, after DGEMM has finished in the previous round of update process, but before the current panel decomposition process has finished, an update of the data exchanged in the current round can be initiated.
[0118] Figure 7 This is a schematic diagram illustrating the collaborative utilization of accelerator computing resources in an update process and a panel decomposition process, as provided in at least one embodiment of this disclosure. Figure 7 As shown, the above process involves the collaborative parallelism of two computational flows: DGEMM and panel decomposition. One type involves the parallel execution of DGEMM and panel decomposition in the previous round of updates, while the other involves the parallel execution of DGEMM and panel decomposition in the current round of updates. The former type of parallelism leads to resource contention but objectively accelerates the computation of the critical path. The latter type of parallelism aims to fully utilize GPU resources, but it also involves resource contention; as the entire HPL computation progresses, it delays the computation of the critical path. Therefore, this collaborative parallelism optimization measure has a termination threshold: when the HPL computation process reaches the critical threshold, the DGEMM process in the current round of updates will no longer be initiated prematurely.
[0119] like Figure 7 As shown, the GPU can also include computational flows executing other kernels. In the GPU, the data in the previous round's tail matrix update process and the data in the current round's partial data update process are unrelated, so they can be computed simultaneously in the GPU. Therefore, in the panel decomposition process, the unrelated update matrix sub-blocks and the panel in the preceding and following update processes can collaboratively utilize GPU computing resources to fully leverage the GPU's computing resources in the heterogeneous computing system. At the same time, it is necessary to comprehensively consider the HPL completion progress to control collaborative usage and ensure maximum HPL performance. In other words, by rearranging and optimizing the functional functions of multiple processing kernels on the GPU, the GPU's computing resources can be fully utilized.
[0120] At least one embodiment of this disclosure also provides a heterogeneous computing system that can undergo HPL testing according to the above-described high-performance Linpack benchmark method, such as... Figure 8 As shown, the heterogeneous computing system 800 includes:
[0121] The central processing unit 801 is configured to acquire the data block to be decomposed in the current sub-decomposition process of the panel decomposition process and to perform triangular decomposition processing on the data block to be decomposed in the current sub-decomposition process to obtain the decomposition result.
[0122] Accelerator 802 is configured to perform block processing on the tail matrix to be updated corresponding to the data block to be decomposed to obtain a first data block and a second data block, and to perform update processing on the first data block to obtain a first update result, and to perform update processing on the second data block to obtain a second update result.
[0123] For example, if the data size of the first data block is less than or equal to the data size of the second data block, the first update result includes the data block to be decomposed in the next sub-decomposition process, and the first update result is used in the next sub-decomposition process earlier than the second update result, so that the accelerator's update processing of the second data block in the current sub-decomposition process and the central processing unit's triangular decomposition processing of the data block to be decomposed in the next sub-decomposition process can be performed in parallel.
[0124] For example, at least one embodiment of the heterogeneous computing system provided in this disclosure also includes a communication network 803 and a memory 804.
[0125] For example, the communication network 803 is configured to enable data interaction between the central processing unit and the accelerator.
[0126] After the accelerator completes the update processing of the first data block, the accelerator sends the first update result to the central processing unit (CPU) through the communication network 803, and the CPU receives the first update result through the communication network 803; and after the accelerator completes the update processing of the second data block, the accelerator sends the second update result to the CPU through the communication network 803, and the CPU receives the second update result through the communication network 803. The first update result is sent to the CPU earlier than the second update result.
[0127] The central processing unit 801 and the accelerator 802 can be connected to each other via a communication network 803, which can be a bus or other high-speed interconnect network. For example, the central processing unit 801 and the accelerator 802 can be connected to each other via a high-speed peripheral component interconnect express (PCIe) interface.
[0128] For example, memory 804 stores executable instructions that are executed by the central processing unit and accelerator to perform triangular decomposition processing on the panel data to be decomposed in the matrix.
[0129] For example, in some embodiments of this disclosure, the memory 804 of the heterogeneous computing system 800 includes the memory 8041 of the central processing unit 801 and the memory 8042 of the accelerator 802. For example, the memory 8041 of the central processing unit 801 and the memory 8042 of the accelerator 802 are independent of each other and can be connected via communication protocols such as PCIe.
[0130] For example, in some embodiments of this disclosure, the panel decomposition code for HPL can be stored in memory 804. The central processing unit 801 and the accelerator 802 implement the high-performance Linpack benchmarking method provided in any embodiment of this disclosure based on the code stored in memory 8041 and memory 8042, respectively. For example, the central processing unit 801 can implement operations such as triangular decomposition and row swapping based on the code stored in memory 8041, and the accelerator 802 can implement operations such as block processing and update processing based on the code stored in memory 8042.
[0131] For example, in some embodiments of this disclosure, the central processing unit 801 is also configured to perform row swapping processing based on the decomposition results.
[0132] For example, in some embodiments of this disclosure, after performing row-swapping processing based on the decomposition results, the central processing unit 801 sends the row-swapping processed data to the accelerator 802, and the accelerator 802 receives the row-swapping processed data.
[0133] For example, in some embodiments of this disclosure, the accelerator 802 is also configured to obtain the tail matrix to be updated corresponding to the data block to be decomposed based on the data after row swapping.
[0134] For example, in some embodiments of this disclosure, the first computing stream of the accelerator 802 is configured to update the first data block to obtain a first update result; the second computing stream of the accelerator 802 is configured to update the second data block to obtain a second update result, wherein the first computing stream, after completing the update processing of the first data block, together with the second computing stream, performs update processing on the second data block.
[0135] The heterogeneous computing system provided in the above embodiments of this disclosure can achieve similar technical effects to the aforementioned high-performance Linpack benchmark testing method, and will not be described in detail here.
[0136] At least one embodiment of this disclosure also provides a non-transitory computer-readable storage medium, wherein the non-transitory computer-readable storage medium stores computer-executable instructions that, when executed by a processor, implement the method according to any embodiment of this disclosure.
[0137] One or more computer-executable instructions may be stored non-transitorily on a storage medium. For example, when the computer-executable instructions are executed by a processor, one or more steps of the high-performance Linpack benchmarking method described above may be performed.
[0138] It should be noted that, in the context of this disclosure, a computer-readable medium can be a tangible medium that may contain or store a program for use by or in conjunction with an instruction execution system, apparatus, or device. A computer-readable medium can be a computer-readable signal medium or a computer-readable storage medium, or any combination thereof. A computer-readable storage medium can be, for example,, but not limited to, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination thereof. For example, a computer-readable storage medium is implemented as a memory, such as volatile memory and / or non-volatile memory. Volatile memory may include, for example, random access memory (RAM) and / or cache, etc. Non-volatile memory may include, for example, read-only memory (ROM), hard disk, erasable programmable read-only memory (EPROM), portable compact disc read-only memory (CD-ROM), USB memory, flash memory, etc. The memory may also store various application programs (code, instructions) and data, as well as various data used and / or generated by the application programs. In this disclosure, a computer-readable storage medium can be any tangible medium that contains or stores a program that can be used by or in connection with an instruction execution system, apparatus, or device. In this disclosure, a computer-readable signal medium can include a data signal propagated in baseband or as part of a carrier wave, carrying computer-readable program code. Such propagated data signals can take various forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination thereof. A computer-readable signal medium can also be any computer-readable medium other than a computer-readable storage medium, which can send, propagate, or transmit a program for use by or in connection with an instruction execution system, apparatus, or device. The program code contained on the computer-readable medium can be transmitted using any suitable medium, including but not limited to: wires, optical fibers, RF (radio frequency), etc., or any suitable combination thereof.
[0139] The non-transitory computer-readable storage medium provided in the above embodiments of this disclosure can achieve similar technical effects to the aforementioned high-performance Linpack benchmark testing method, and will not be described again here.
[0140] Although the present disclosure has been described in detail above with general descriptions and specific embodiments, modifications or improvements can be made to the embodiments of the present disclosure, which will be obvious to those skilled in the art. Therefore, all such modifications or improvements made without departing from the spirit of the present disclosure are within the scope of protection claimed by the present disclosure.
[0141] The following points should be noted regarding this disclosure:
[0142] (1) The accompanying drawings of the embodiments of this disclosure only involve the structures involved in the embodiments of this disclosure. Other structures can be referred to the general design.
[0143] (2) For clarity, the thickness of layers or regions in the drawings used to describe embodiments of the present disclosure is enlarged or reduced, i.e., these drawings are not drawn to actual scale.
[0144] (3) Where there is no conflict, the embodiments of this disclosure and the features in the embodiments can be combined with each other to obtain new embodiments.
[0145] The above description is merely a specific embodiment of this disclosure, but the scope of protection of this disclosure is not limited thereto. The scope of protection of this disclosure should be determined by the scope of protection of the claims.
Claims
1. A high-performance Linpack benchmarking method for heterogeneous computing systems including central processing units and accelerators, the method comprising: In the panel decomposition process of performing triangular decomposition on the panel data to be decomposed in the matrix, Obtain the data block to be decomposed in the current sub-decomposition process of the panel decomposition process; The central processing unit performs triangular decomposition processing on the data blocks to be decomposed in the current sub-decomposition process to obtain the decomposition result; The tail matrix to be updated corresponding to the data block to be decomposed is divided into blocks to obtain a first data block and a second data block, wherein the data size of the first data block is less than or equal to the data size of the second data block. The first data block is updated using an accelerator to obtain a first update result, and the second data block is updated to obtain a second update result. The first update result includes the data block to be decomposed in the next sub-decomposition process, and the first update result is used in the next sub-decomposition process earlier than the second update result, so that the accelerator's update processing of the second data block in the current sub-decomposition process and the central processing unit's triangular decomposition processing of the data block to be decomposed in the next sub-decomposition process can be performed in parallel. The step of updating the first data block using an accelerator to obtain a first update result, and updating the second data block to obtain a second update result, includes: The first data block is updated using the first computing stream of the accelerator to obtain a first update result; The second data block is updated using the second computational stream of the accelerator to obtain a second update result. In this process, after the first computing stream completes the update processing of the first data block, it works together with the second computing stream to update the second data block.
2. The method according to claim 1, wherein, The panel decomposition process is implemented using only a non-recursive algorithm.
3. The method according to claim 2, wherein, The non-recursive algorithm includes loop processing.
4. The method according to claim 1, wherein, The accelerator includes a graphics processor.
5. The method according to claim 1, wherein, The size of both the data block to be decomposed and the first data block is the minimum decomposition block size.
6. The method according to claim 1, further comprising: The central processing unit interacts with the accelerator via data exchange, including: After the accelerator completes the update process on the first data block, the accelerator sends the first update result to the central processing unit, and the central processing unit receives the first update result; and After the accelerator completes the update process for the second data block, the accelerator sends the second update result to the central processing unit (CPU). The CPU receives the second update result, and the first update result is sent to the CPU earlier than the second update result.
7. The method according to claim 6, further comprising: The central processing unit performs row swapping processing based on the decomposition results.
8. The method according to claim 7, wherein, The central processing unit interacts with the accelerator via data exchange, and the process also includes: After performing the row swapping process based on the decomposition results, the central processing unit sends the row swapped data to the accelerator, and the accelerator receives the row swapped data.
9. The method according to claim 8, further comprising: Based on the data after the row swapping process, obtain the tail matrix to be updated corresponding to the data block to be decomposed.
10. The method according to claim 1, further comprising: In the previous round of updates, some data underwent row swapping. After the row exchange and update processes are completed, the panel decomposition process for the current round is started ahead of schedule.
11. The method of claim 10, further comprising: During the period between the completion of matrix multiplication in the previous round of update and the completion of panel decomposition in the current round, the accelerator performs matrix multiplication on the data that has already undergone row swapping in advance, in accordance with the matrix multiplication process in the current round of update.
12. The method according to claim 10 or 11, wherein, The accelerator prioritizes the computational flow during the current round of panel decomposition over the computational flow during the update process.
13. A heterogeneous computing system, comprising a central processing unit and an accelerator. in, In the panel decomposition process of performing triangular decomposition on the panel data to be decomposed in the matrix, The central processing unit is configured to acquire the data block to be decomposed in the current sub-decomposition process of the panel decomposition process and perform triangular decomposition processing on the data block to be decomposed in the current sub-decomposition process to obtain the decomposition result; The accelerator is configured to perform block processing on the tail matrix to be updated corresponding to the data block to be decomposed to obtain a first data block and a second data block, and to perform update processing on the first data block to obtain a first update result, and to perform update processing on the second data block to obtain a second update result. Wherein, the data size of the first data block is less than or equal to the data size of the second data block, the first update result includes the data block to be decomposed in the next sub-decomposition process, and the first update result is used in the next sub-decomposition process earlier than the second update result, so that the accelerator's update processing of the second data block in the current sub-decomposition process and the central processing unit's triangular decomposition processing of the data block to be decomposed in the next sub-decomposition process can be performed in parallel. The first computing stream of the accelerator is configured to update the first data block to obtain the first update result; the second computing stream of the accelerator is configured to update the second data block to obtain the second update result, wherein the first computing stream, after completing the update processing of the first data block, together with the second computing stream, performs update processing on the second data block.
14. The heterogeneous computing system according to claim 13, further comprising: A communication network is configured to enable data interaction between the central processing unit and the accelerator. Wherein, after the accelerator completes the update processing of the first data block, the accelerator sends the first update result to the central processing unit through the communication network, and the central processing unit receives the first update result through the communication network; and After the accelerator completes the update process for the second data block, the accelerator sends the second update result to the central processing unit through the communication network. The central processing unit receives the second update result through the communication network. The first update result is sent to the central processing unit earlier than the second update result.
15. The heterogeneous computing system according to claim 13, further comprising: The memory stores executable instructions that are executed by the central processing unit and the accelerator to perform triangular decomposition processing on the panel data to be decomposed in the matrix.
16. A non-transitory computer-readable storage medium, wherein, The non-transitory computer-readable storage medium stores computer-executable instructions that, when executed by a processor, implement the method according to any one of claims 1-12.
Citation Information
Patent Citations
Method for achieving large-scale high-performance Linpack testing benchmark for GPDSP
CN104615516A
Method for vectorization computing of solution of large-scale trigonometric linear system of equations for GPDSP
CN104615584A
