Method for solving large-scale linear programming problem based on heterogeneous computing

Abstract

The application relates to a large-scale linear programming problem solving method based on heterogeneous computing, and belongs to the technical field of high-performance computing. The application parallelizes a standard simplex method of a linear programming problem by utilizing different characteristics of a host and parallel computing equipment. Firstly, the computing task of the simplex is decomposed, and different computing tasks are allocated to the host and the computing equipment; on this basis, a reasonable data transmission strategy is designed between the host and the equipment, so that the computing performance is improved; finally, a parallel algorithm of a pivot transformation is designed, and the parallelism of the computing equipment is utilized to overcome the defects of the simplex method, such as many pivot transformation rounds and large computing amount.

Description

Technical Field

[0001] This invention belongs to the field of high-performance computing technology, specifically relating to a method for solving large-scale linear programming problems based on heterogeneous computing. Background Technology

[0002] With the continuous maturation of various hardware accelerator card technologies, represented by GPUs, heterogeneous computing has become one of the important means to solve large-scale computational problems. Heterogeneous computing requires coordinating various computing devices, including CPUs (such as GPUs, FPGAs, DSPs, etc.), to allocate computing tasks to different computing devices according to their characteristics, giving full play to the different features of various computing devices and working together to solve the problem.

[0003] In the field of heterogeneous computing, Open Computing Language (OpenCL) is a language that can shield the heterogeneity of various computing devices and provide a unified interface for users to easily write heterogeneous computing programs. Currently, OpenCL has gained widespread support from major vendors and is widely used in server, desktop, and embedded environments.

[0004] OpenCL platform model such as Figure 1 As shown, OpenCL defines a computer as a host plus an OpenCL device. The host typically refers to the CPU and memory, while the OpenCL device represents OpenCL's unified abstraction of various heterogeneous computing devices. Inside the computing device, OpenCL manages individual kernels through Compute Units. Computational tasks are performed by kernels within the Compute Unit, with each kernel executing one thread. When executing a computational task, the host first compiles the OpenCL program, then sends the data to be computed and the compiled OpenCL program to the device via the bus, where the device executes the specified computational task. During this process, multiple data exchanges may occur between the host and the device, as well as between different storage areas of the device. After the computational task is completed, the host retrieves the computation result from the device and returns it to the end user.

[0005] In addition to abstracting computing devices, OpenCL also designed a unified memory model to address the data transfer problem during computation, such as... Figure 2 As shown, OpenCL divides the memory of a computing device into four logical spaces: private memory, local memory, constant memory, and global memory.

[0006] • Private memory: Registers that each kernel on the device has and can only be accessed by the current thread;

[0007] • Local clusterer: An on-chip memory shared by a group of kernels, accessible to all threads in a workgroup;

[0008] • Constant memory: A portion of the device's off-chip memory whose contents cannot be changed after initialization. Generally, constant memory is automatically supported by the device's internal dedicated constant cache, resulting in low access latency; constant memory can be accessed by all threads.

[0009] • Global Memory: Off-chip physical memory of the device, with a large storage capacity but high access latency, and can be accessed by all threads;

[0010] Optimizing data layout, designing efficient data transmission strategies, and rationally allocating computing tasks on the host and various parallel computing devices to fully leverage their respective performance advantages are the main issues to consider when using OpenCL to solve large-scale computational problems.

[0011] Linear programming is an important class of optimization problems that solve for the extrema of a linear objective function under linear constraints. It has wide applications in various aspects of socio-economic life. The standard model of a linear programming problem is:

[0012]

[0013] Where c is the objective function coefficient vector, A is the coefficient matrix of the constrained linear equation system, b is the right-hand vector of the constrained linear equation system, and x is the decision variable. m < n, rank(A) = m.

[0014] The basic solution method for linear programming problems is the simplex method, and its basic process is as follows:

[0015] S1. Let the first m columns of A be the basis vectors. These basis vectors form the basis matrix B, and the remaining column vectors form the non-basis matrix D.

[0016] S2, let c T The first m components are the components corresponding to the basis vectors, denoted as vector c. B The remaining components form vector c. D ;

[0017] S3. Construct the simplex tableau from the standard model of the linear programming problem shown in formula (1):

[0018]

[0019] S4. Multiply the matrix on the right side of equation (2) by the left multiplier. Transform the augmented matrix [A b] in the simplex tableau into normal form:

[0020]

[0021] Among them I m B is an m-order identity matrix. -1 Let B be the inverse of the basis matrix B. If B -1 If it does not exist, then the linear programming problem has no solution;

[0022] S5. Multiply the matrix on the right side of equation (3) by the left multiplier. Change the elements in the last row of the matrix on the right-hand side of equation (3) that correspond to the basis column vectors to zero:

[0023]

[0024] In formula (4), the matrix on the right-hand side of the equal sign is called the standard simplex tableau of the linear programming problem with respect to basis B, where:

[0025] c) In the last column of the standard simplex tableau, the first m elements B -1 b is a basic variable about B;

[0026] d) In the last row of the standard simplex tableau, it is called Let r be the test number. i i = m+1, ..., n The negative of the objective function value for the current basic feasible solution;

[0027] S6. If all test numbers r i If ≥0, i=m+1,…,n, then stop the calculation, and the current basic feasible solution is the optimal solution; otherwise, proceed to the next step.

[0028] S7. Calculate the indices of the entering and leaving column vectors according to formulas (5) and (6) respectively, where q is the indices of the entering column vector and p is the indices of the leaving column vector:

[0029] q=min{i:r i <0} (5)

[0030]

[0031] Where y ij This represents the element at position (i,j) in the simplex tableau; y j0 This indicates that B in the last column of the simplex tableau -1 The value of the j-th basic variable of b;

[0032] S8. Using (p,q) as the pivot element, perform a pivot transformation on the simplex tableau according to formula (7):

[0033]

[0034] Where yi ' j The element at (i,j) in the transformed simplex tableau; proceed to step S6.

[0035] Analysis of the simplex method's processing steps reveals two main steps: first, constructing a standard simplex tableau; and second, performing pivot transformations on the standard simplex tableau. As the number of decision variables and constraints increases, the simplex tableau becomes increasingly large, reaching hundreds of millions or even billions of elements in real-world problems. Furthermore, because pivot transformations require updating the entire simplex tableau, and the number of pivot transformations increases with the number of decision variables, pivot transformations represent a critical performance bottleneck for the simplex method.

[0036] This invention provides a method for solving large-scale linear programming problems based on heterogeneous computing. By analyzing the solution process of the simplex method and rationally allocating computing tasks on the host and parallel computing devices, large-scale linear programming problems can be solved relatively quickly. Summary of the Invention

[0037] (a) Technical problems to be solved

[0038] The technical problem to be solved by this invention is how to provide a solution method for large-scale linear programming problems based on heterogeneous computing, so as to overcome the bottleneck problem of the simplex method in solving linear programming problems.

[0039] (II) Technical Solution

[0040] To address the aforementioned technical problems, this invention proposes a method for solving large-scale linear programming problems based on heterogeneous computing. This method includes the following steps:

[0041] Step 1: Input the relevant parameters c, A, b from the standard linear programming model into the computer. At the same time, you also need to provide the initial set of basis column vector indices v.

[0042] Step 2: The host initializes the OpenCL heterogeneous computing environment, in which the host reads and parses the pivot transformation module;

[0043] Step 3: The host computer constructs the simplex tableau for the linear programming problem according to formula (2);

[0044] Step 4: The host checks whether the basis matrix is ​​invertible. If the basis matrix is ​​invertible, proceed to the next step; otherwise, the linear programming problem has no solution, and the algorithm ends.

[0045] Step 5: The host computer converts the simplex tableau obtained in Step 3 into a standard simplex tableau according to formulas (3) and (4):

[0046] Step 6: The host requests memory space from the OpenCL device;

[0047] Step 6.1: The OpenCL device creates a buffer in global memory according to the size of the standard simplex table;

[0048] Step 6.2: The OpenCL device creates a buffer in constant memory according to the size of 1 row of the standard simplex table;

[0049] Step 7: The host requests the creation of a kernel object from the OpenCL device and sets the parameters according to the pivot transformation module. The parameters of the kernel object are the same as those of the pivot transformation module.

[0050] Step 8: The host transfers the standard simplex table to the OpenCL device, specifically to the global memory buffer created in step 6.1;

[0051] Step 9: The host checks whether all test numbers are non-negative; if all test numbers are non-negative, it means that the solution corresponding to the current basis column vector is the optimal solution, and proceeds to step 18; otherwise, proceed to the next step.

[0052] Step 10: The host calculates the basic variable q according to formula (5);

[0053] Step 11: The OpenCL device transmits the q-th column of the updated simplex tableau to the host;

[0054] Step 12: The OpenCL device transmits the last column of the updated simplex tableau to the host;

[0055] Step 13: The host computer calculates the differential variable p according to formula (6);

[0056] Step 14: The host updates the set of basis column vector indices v, letting v p =q;

[0057] Step 15: The host transmits (p,q) to the OpenCL device;

[0058] Step 16: The OpenCL device performs a parallel pivot transformation on the simplex tableau with the element at position (p,q) as the pivot element;

[0059] Step 17: The OpenCL device transmits the last row of the updated simplex tableau to the host; proceed to step 9;

[0060] Step 18: The OpenCL device transmits the last column of the updated simplex tableau to the host;

[0061] Step 19: The host obtains the optimal solution from the last column of the standard simplex tableau according to the position of the current basis column vector;

[0062] Step 20: The host cleans up the OpenCL computing environment, releases allocated memory and related objects, and the computing ends;

[0063] The standard model for linear programming problems is:

[0064]

[0065] Where c is the objective function coefficient vector, A is the coefficient matrix of the constrained linear equation system, b is the right-hand vector of the constrained linear equation system, and x is the decision variable. m < n, rank(A) = m.

[0066] The basic process of solving linear programming problems using the simplex method is as follows:

[0067] S1. Let the first m columns of A be the basis vectors. These basis vectors form the basis matrix B, and the remaining column vectors form the non-basis matrix D.

[0068] S2, let c T The first m components are the components corresponding to the basis vectors, denoted as vector c. B The remaining components form vector c. D ;

[0069] S3. Construct the simplex tableau from the standard model of the linear programming problem shown in formula (1):

[0070]

[0071] S4. Multiply the matrix on the right side of equation (2) by the left multiplier. Transform the augmented matrix [A b] in the simplex tableau into normal form:

[0072]

[0073] Among them I m B is an m-order identity matrix. -1 Let B be the inverse of the basis matrix B. If B -1 If it does not exist, then the linear programming problem has no solution;

[0074] S5. Multiply the matrix on the right side of equation (3) by the left multiplier. Change the elements in the last row of the matrix on the right-hand side of equation (3) that correspond to the basis column vectors to zero:

[0075]

[0076] In formula (4), the matrix on the right-hand side of the equal sign is called the standard simplex tableau of the linear programming problem with respect to basis B, where:

[0077] e) In the last column of the standard simplex tableau, the first m elements B -1b is a basic variable about B;

[0078] f) In the last row of the standard simplex tableau, it is called Let r be the test number. i i = m+1, ..., n The negative of the objective function value for the current basic feasible solution;

[0079] S6. If all test numbers r i If ≥0, i=m+1,…,n, then stop the calculation, and the current basic feasible solution is the optimal solution; otherwise, proceed to the next step.

[0080] S7. Calculate the indices of the entering and leaving column vectors according to formulas (5) and (6) respectively, where q is the indices of the entering column vector and p is the indices of the leaving column vector:

[0081] q=min{i:r i <0} (5)

[0082]

[0083] Where y ij This represents the element at position (i,j) in the simplex tableau; y j0 This indicates that B in the last column of the simplex tableau -1 The value of the j-th basic variable of b;

[0084] S8. Using (p,q) as the pivot element, perform a pivot transformation on the simplex tableau according to formula (7):

[0085]

[0086] Where y i ' j The element at (i,j) in the transformed simplex tableau; proceed to step S6.

[0087] (III) Beneficial Effects

[0088] This invention proposes a method for solving large-scale linear programming problems based on heterogeneous computing. The innovations of this invention are as follows: First, considering the different characteristics of the host and the computing device, the overall computational task of the simplex method is divided: the host performs the determination of the test number and the calculation of the basis and non-basis vectors, while the computing device performs the pivot transformation. This design fully utilizes the host's strength in logical judgment and the computing device's strength in parallel execution of a large number of simple calculations. Second, based on the above task decomposition, a reasonable data transmission strategy between the host and the device is designed to maintain a small data transmission volume (1 row + 2 columns of the simplex tableau) during each round of pivot transformation, further improving the efficiency of parallel computing. Third, on the computing device, a parallel computing method for implementing the pivot transformation is designed. Before each round of pivot transformation, the p-th row of the simplex tableau is copied to the constant storage area, fully utilizing the performance advantage of the constant storage area of ​​the parallel computing device. Simultaneously, the pivot transformation on the entire simplex tableau is distributed to multiple work items on the computing device, further improving the execution efficiency of the algorithm. Attached Figure Description

[0089] Figure 1 This is a schematic diagram of the OpenCL platform model;

[0090] Figure 2 This is a schematic diagram of an OpenCL memory model;

[0091] Figure 3 A schematic diagram illustrating the basic process of solving large-scale linear programming problems based on heterogeneous computing;

[0092] Figure 4 The basic process of initializing the OpenCL computing environment;

[0093] Figure 5 Flowchart for the parallel pivot transformation module;

[0094] Figure 6 The process by which the host requests memory space from an OpenCL device;

[0095] Figure 7 The process by which the host requests the creation of a kernel object from the OpenCL device and sets its parameters;

[0096] Figure 8 This describes the process by which the host transfers (p,q) to the OpenCL device.

[0097] Figure 9 The process of pivoting an OpenCL device. Detailed Implementation

[0098] This invention proposes a method for solving large-scale linear programming problems based on heterogeneous computing. It parallelizes the simplex method, the standard algorithm for solving linear programming problems, by leveraging the different characteristics of host computers and parallel computing devices. First, the computational task of the simplex method is decomposed, assigning different computational tasks to the host computer and the computing devices. Based on this, a reasonable data transmission strategy is designed between the host computer and the devices to improve computational performance. Finally, a parallel algorithm for pivot transformation is designed, overcoming the drawbacks of the simplex method—numerous pivot transformation rounds and large computational load—by utilizing the parallelism of the computing devices.

[0099] This invention provides a method for solving large-scale linear programming problems based on heterogeneous computing, the basic process of which is as follows: Figure 3 As shown, the detailed steps include:

[0100] Step 1: Input the relevant parameters c, A, b from the standard linear programming model into the computer. At the same time, you also need to provide the initial set of basis column vector indices v.

[0101] Step 2: The host initializes the OpenCL heterogeneous computing environment, where the host reads and parses the pivot transformation module, as shown in the following steps. Figure 4 As shown:

[0102] Step 2.1: Obtain the heterogeneous computing platform ID on the current computer;

[0103] Step 2.2: Obtain the device ID on the current heterogeneous computing platform;

[0104] Step 2.3: Create a heterogeneous computing environment context object using the device ID on the current heterogeneous computing platform;

[0105] Step 2.4: Create a command queue using the heterogeneous computing environment context object. The host sends commands to the OpenCL device through the command queue.

[0106] Step 2.5: The host reads and parses the pivot transformation module, which contains 6 input parameters: mat, row_p, n_row, n_col, p, and q.

[0107] 1) mat: An array that stores the standard simplex tableau, located in global memory;

[0108] 2) row_p: An array that stores the p-th row of the simplex tableau, located in constant memory;

[0109] 3) n_row: The number of rows in the simplex tableau, a positive integer.

[0110] 4) n_col: The number of columns in the simplex tableau, a positive integer.

[0111] 5) p: Pivot transformation parameter

[0112] 6) q: Pivot transformation parameter

[0113] The pivot transformation module is responsible for performing parallel pivot transformations on the simplex tableau on the device according to formula (7). The detailed processing steps are as follows: Figure 5 As shown. In subsequent step 16.3, the kernel object created based on this module will be invoked to perform parallel pivot transformation:

[0114] Step 2.5.1: Obtain the current work item number, denoted as i;

[0115] Step 2.5.2: Obtain the element in the i-th row and q-th position of the simplex tableau from mat, denoted as y. iq ;

[0116] Step 2.5.3: Get the q-th element of row_p, denoted as y. pq ;

[0117] Step 2.5.4: Calculate r = y iq / y pq ;

[0118] Step 2.5.5: Let j = 1;

[0119] Step 2.5.6: Check if j≥1 and j≤n_col. If yes, proceed to step 2.5.7; otherwise, the module call ends.

[0120] Step 2.5.7: Check if i = p. If yes, proceed to step 2.5.8; otherwise, proceed to step 2.5.9.

[0121] Step 2.5.8: Calculate y′ ij =y ij / y pq Proceed to step 2.5.11;

[0122] Step 2.5.9: Get the j-th element of row_p, denoted as y. pj ;

[0123] Step 2.5.10: Calculate y′ ij =y ij -y pj ×r, proceed to step 2.5.11;

[0124] Step 2.5.11: j = j + 1;

[0125] Step 3: The host computer constructs the simplex tableau for the linear programming problem according to formula (2);

[0126] Step 4: The host checks whether the basis matrix is ​​invertible. If the basis matrix is ​​invertible, proceed to the next step; otherwise, the linear programming problem has no solution, and the algorithm ends.

[0127] Step 5: The host computer converts the simplex tableau obtained in Step 3 into a standard simplex tableau according to formulas (3) and (4):

[0128] Step 6: The host requests memory space from the OpenCL device, such as... Figure 6 As shown:

[0129] Step 6.1: The OpenCL device creates a buffer in global memory according to the size of the standard simplex table;

[0130] Step 6.2: The OpenCL device creates a buffer in constant memory according to the size of 1 row of the standard simplex table;

[0131] Step 7: The host requests the creation of a kernel object from the OpenCL device and sets its parameters according to the pivot transformation module. The parameters of the kernel object are the same as those of the pivot transformation module, such as... Figure 7 As shown:

[0132] Step 7.1: The OpenCL device creates a kernel object kernel(mat,pRow,m,n,p,q), where p and q are pivot transformation parameters, which will be given in subsequent step 15;

[0133] Step 7.2: The OpenCL device sets the first parameter mat of the kernel object to the global memory buffer created in step 6.1;

[0134] Step 7.3: The OpenCL device sets the second parameter pRow of the kernel object to the constant memory buffer created in step 6.2;

[0135] Step 7.4: The OpenCL device sets the third parameter m of the kernel object to the number of rows in the standard simplex tableau;

[0136] Step 7.5: The OpenCL device sets the fourth parameter n of the kernel object to the number of columns in the standard simplex tableau;

[0137] Step 8: The host transfers the standard simplex table to the OpenCL device, specifically to the global memory buffer created in step 6.1;

[0138] Step 9: The host checks whether all test numbers are non-negative; if all test numbers are non-negative, it means that the solution corresponding to the current basis column vector is the optimal solution, and proceeds to step 18; otherwise, proceed to the next step.

[0139] Step 10: The host calculates the basic variable q according to formula (5);

[0140] Step 11: The OpenCL device transmits the q-th column of the updated simplex tableau to the host;

[0141] Step 12: The OpenCL device transmits the last column of the updated simplex tableau to the host;

[0142] Step 13: The host computer calculates the differential variable p according to formula (6);

[0143] Step 14: The host updates the set of basis column vector indices v, letting v p =q;

[0144] Step 15: The host transmits (p,q) to the OpenCL device, such as... Figure 8 As shown:

[0145] Step 15.1: The OpenCL device sets the value of the fifth parameter p of the kernel object to p;

[0146] Step 15.2: The OpenCL device sets the value of the 6th parameter q of the kernel object to q;

[0147] Step 16: The OpenCL device performs a parallel pivot transformation on the simplex tableau, using the element at position (p, q) as the pivot element, as follows: Figure 9 As shown:

[0148] Step 16.1: The OpenCL device copies the p-th row of the current simplex tableau to the constant memory buffer created in step 6.2;

[0149] Step 16.2: Based on the relevant information of the OpenCL device, determine the values ​​of the relevant parameters for performing parallel computing, such as the number of workgroups and the number of work items;

[0150] Step 16.3: The OpenCL device creates relevant workgroups and work items, and each work item performs a pivot transformation on row 1 of the simplex tableau according to formula (7); where the data of the required p-th row is read from the constant memory buffer created in step 6.2;

[0151] Step 17: The OpenCL device transmits the last row of the updated simplex tableau to the host; proceed to step 9;

[0152] Step 18: The OpenCL device transmits the last column of the updated simplex tableau to the host;

[0153] Step 19: The host obtains the optimal solution from the last column of the standard simplex tableau according to the position of the current basis column vector;

[0154] Step 20: The host cleans up the OpenCL computing environment, releases allocated memory and related objects, and the computing ends.

[0155] In the simplex method, a standard simplex tableau is first constructed. Based on this, multiple rounds of pivot transformations are performed on the tableau. After each pivot transformation, the test result is checked for negative values. If negative values ​​exist, the out-of-basic and in-basic column vectors must be determined. The pivot transformation is then performed again until all test results are non-negative, yielding the optimal solution. In this process, the multiple rounds of pivot transformations are the performance bottleneck of the entire algorithm.

[0156] Example 1:

[0157] The specific implementation of this invention is illustrated by solving a linear programming problem. This problem will be solved in a heterogeneous computing environment using a CPU and GPU, where the CPU is an Intel i7 11800H and the GPU is an NVIDIA GeForce RTX 3050 Ti. The data type used during the calculation is 32-bit single-precision floating-point numbers.

[0158] It should be noted that, due to space limitations, the scale of the problem to be solved is not large. In practice, this invention can be used to quickly solve larger-scale linear programming problems.

[0159] Problem Definition

[0160] The linear programming problem to be solved is as follows:

[0161]

[0162] First, the problem is reorganized into the standard model of a linear programming problem as shown in formula (1), where:

[0163]

[0164] Observing that the first 3 columns of the augmented matrix of the equation Ax=b are already a basis matrix, the corresponding basic variables have formed a basic feasible solution. The subscript of the basis column vector is v=[1 2 3]. Therefore, we can start from this basic feasible solution and use the parallel simplex method proposed in this invention to find the optimal solution.

[0165] Solution steps

[0166] Step 1: Input c, A, b, v as parameters into the computer and initiate a calculation request;

[0167] Step 2: Initialize the OpenCL heterogeneous computing environment on the host machine. Specific steps include:

[0168] Step 2.1: Obtain the heterogeneous computing platform ID on the current computer;

[0169] Step 2.2: Obtain the device ID on the current heterogeneous computing platform;

[0170] Step 2.3: Create a heterogeneous computing environment context object using the device ID on the current heterogeneous computing platform;

[0171] Step 2.4: Create a command queue using the heterogeneous computing environment context object. The host sends commands to the OpenCL device through the command queue.

[0172] Step 2.5: The host computer reads and parses the parallel pivot transformation module;

[0173] Step 3: After receiving the parameters c, A, b, v, the host constructs a simplex tableau according to formula (2):

[0174]

[0175] In the simplex tableau shown in formula (10), the basis matrix is...

[0176] Step 4: The basis matrix B is invertible, proceed to step 5;

[0177] Step 5: The host computer converts the simplex tableau obtained in Step 3 into a standard simplex tableau according to formulas (3) and (4) (here, the standard simplex tableau happens to be the same as the original simplex tableau):

[0178]

[0179] Step 6: The host requests memory space from the OpenCL device:

[0180] Step 6.1: The OpenCL device creates a buffer of size 4×8×4=128 bytes on global memory;

[0181] Step 6.2: The OpenCL device creates a buffer of 8 × 4 = 32 bytes in constant memory;

[0182] Step 7: Based on the parallel pivot transformation module obtained in Step 2.5, the host requests the creation of a kernel object from the OpenCL device and sets its parameters:

[0183] Step 7.1: The OpenCL device creates a kernel object kernel(mat,pRow,m,n,p,q);

[0184] Step 7.2: The OpenCL device sets the first parameter mat of the kernel object to the global memory buffer created in step 6.1;

[0185] Step 7.3: The OpenCL device sets the second parameter pRow of the kernel object to the constant memory buffer created in step 6.2;

[0186] Step 7.4: OpenCL sets the third parameter m of the kernel object to 4, which is the number of rows in the standard simplex tableau;

[0187] Step 7.5: OpenCL sets the fourth parameter n of the kernel object to 8, which is the number of columns in the standard simplex tableau;

[0188] Step 8: The host transfers the standard simplex table to the OpenCL device, specifically to the global memory buffer created in step 6.1;

[0189] First transformation

[0190] Step 9: The host computer checks whether all check numbers are non-negative. Therefore, a pivot transformation is required for the simplex tableau:

[0191] Step 10: The host computer obtains the basic variable q = 4 from formula (5);

[0192] Step 11: The OpenCL device sets the fourth column of the simplex tableau, a4 = [1 / 4 1 / 2 0 -3 / 4]. T Transmitted to the host;

[0193] Step 12: The OpenCL device will extract the last column of the simplex tableau [0 0 1 0]. T Transmitted to the host;

[0194] Step 13: The host computer calculates the free radical variable p = 1 using formula (6):

[0195]

[0196] Step 14: The host updates the set of base column vector indices to obtain v = [4 2 3];

[0197] Step 15: The host transmits p=1, q=4 to the OpenCL device.

[0198] Step 15.1: The OpenCL device sets the value of the fifth parameter p of the kernel object to 1;

[0199] Step 15.2: The OpenCL device sets the value of the 6th parameter q of the kernel object to 4;

[0200] Step 16: OpenCL device with y 14 Using pivot elements, perform a pivot transformation on the simplex tableau:

[0201] Step 16.1: The OpenCL device copies the first row of the current simplex tableau to the constant memory buffer created in step 6.2;

[0202] Step 16.2: Set the number of workgroups to 4, with 1 work item in each workgroup; each work item is responsible for updating 1 row in the simplex tableau;

[0203] Step 16.3: For each work item, perform a pivot transformation on row 1 of the simplex tableau according to formula (7). During the calculation, y 1j The value is read from the constant memory buffer created in step 6.2;

[0204] The updated simplex tableau is shown below:

[0205]

[0206] Step 17: The OpenCL device transmits the last row of the updated simplex tableau [3 0 0 0 -4 -7 / 2 33 0] to the host;

[0207] Second transformation

[0208] Step 18: The host checks whether all test numbers are non-negative. Test number r5 = -4 < 0, so a pivot transformation of the simplex tableau is required.

[0209] Step 19: The host obtains the basic variable q = 5 from formula (5);

[0210] Step 20: The OpenCL device updates the 5th column of the standard simplex tableau [-32 4 0 -4]. T Transmitted to the host;

[0211] Step 21: The OpenCL device updates the last column of the standard simplex tableau [0 0 1 0]. T Transmitted to the host;

[0212] Step 22: The host computer calculates the free radical variable p = 2 using formula (6):

[0213]

[0214] Step 23: The host updates the index set of the base column vector set to obtain v = [4 5 3];

[0215] Step 24: The host transmits parameters p=2, q=5 to the OpenCL device.

[0216] Step 24.1: The OpenCL device sets the value of the fifth parameter p of the kernel object to 2;

[0217] Step 24.2: The OpenCL device sets the value of the 6th parameter q of the kernel object to 5;

[0218] Step 25: OpenCL device with y25 Using pivot elements, perform a pivot transformation on the simplex tableau:

[0219] Step 25.1: The OpenCL device copies the second row of the current simplex tableau to the constant memory buffer created in step 6.2;

[0220] Step 25.2: Set the number of workgroups to 4, with 1 work item in each workgroup; each work item is responsible for updating 1 row in the simplex tableau;

[0221] Step 25.3: For each work item, perform a pivot transformation on row 1 of the simplex tableau according to formula (7). During the calculation, y 2j The value is read from the constant memory buffer created in step 6.2;

[0222] The updated simplex tableau is shown below:

[0223]

[0224] Step 26: The OpenCL device transmits the last row of the updated simplex tableau [1 1 0 0 0 -2 18 0] to the host;

[0225] 3rd transformation

[0226] Step 27: The host checks whether all test numbers are non-negative. r6 = -2 < 0, so a pivot transformation of the simplex tableau is required.

[0227] Step 28: The host obtains the basic variable q = 6 from formula (5);

[0228] Step 29: The OpenCL device sets the 6th column of the simplex tableau, a6 = [8 3 / 8 1 -2]. T Transmitted to the host;

[0229] Step 30: The OpenCL device will extract the last column of the simplex tableau [0 0 1 0]. T Transmitted to the host;

[0230] Step 31: The host computer calculates the free radical variable p = 1 using formula (6):

[0231]

[0232] Step 32: The host updates the set of base column vector indices to obtain v = [6 5 3];

[0233] Step 33: The host transmits p=1, q=6 to the OpenCL device.

[0234] Step 33.1: The OpenCL device sets the value of the fifth parameter p of the kernel object to 1;

[0235] Step 33.2: The OpenCL device sets the value of the 6th parameter q of the kernel object to 6;

[0236] Step 34: OpenCL device with y 16 Using pivot elements, perform a pivot transformation on the simplex tableau:

[0237] Step 34.1: The OpenCL device copies the first row of the current simplex tableau to the constant memory buffer created in step 6.2;

[0238] Step 34.2 Set the number of workgroups to 4, with 1 work item in each workgroup; each work item is responsible for updating 1 row in the simplex tableau;

[0239] Step 34.3: For each work item, perform a pivot transformation on row 1 of the simplex tableau according to formula (7). During the calculation, y 1j The value is read from the constant memory buffer created in step 6.2;

[0240] The updated simplex tableau is shown below:

[0241]

[0242] Step 35: The OpenCL device transmits the last row of the updated simplex tableau [-2 3 0 1 / 4 0 0 -3 0] to the host;

[0243] 4th transformation

[0244] Step 36: The host computer checks whether all test numbers are non-negative. Since r1 = -2 < 0, a pivot transformation of the simplex tableau is required.

[0245] Step 37: The host obtains the basic variable q = 1 from formula (5);

[0246] Step 38: The OpenCL device updates the first column of the simplex tableau, a1 = [-3 / 2 1 / 16 3 / 2 -2]. T Transmitted to the host;

[0247] Step 39: The OpenCL device updates the last column of the simplex tableau [0 0 1 0]. T Transmitted to the host;

[0248] Step 40: The host computer calculates the free radical variable p = 2 using formula (6):

[0249]

[0250] Step 41: The host updates the set of base column vector indices to obtain v = [6 1 3];

[0251] Step 42: The host transmits p=2, q=1 to the OpenCL device.

[0252] Step 42.1: The OpenCL device sets the value of the fifth parameter p of the kernel object to 2;

[0253] Step 42.2: The OpenCL device sets the value of the 6th parameter q of the kernel object to 1;

[0254] Step 43: OpenCL device with y 21 Using pivot elements, perform a pivot transformation on the simplex tableau:

[0255] Step 43.1: The OpenCL device copies the second row of the current simplex tableau to the constant memory buffer created in step 6.2;

[0256] Step 43.2: Set the number of workgroups to 4, with 1 work item in each workgroup; each work item is responsible for updating 1 row in the simplex tableau;

[0257] Step 43.3: For each work item, perform a pivot transformation on row 1 of the simplex tableau according to formula (7). During the calculation, y 2j The value is read from the constant memory buffer created in step 6.2;

[0258] The updated simplex tableau is shown below:

[0259]

[0260] 5th transformation

[0261] Step 44: The host computer checks whether all test numbers are non-negative. Since r² = -1 < 0, a pivot transformation of the simplex tableau is required.

[0262] Step 45: The host obtains the basic variable q = 2 from formula (5);

[0263] Step 46: The OpenCL device sets the second column of the simplex tableau, a2 = [-2 -2 2 -1]. T Transmitted to the host;

[0264] Step 47: The OpenCL device will extract the last column of the simplex tableau [0 0 1 0]. T Transmitted to the host;

[0265] Step 48: The host computer calculates the free radical variable p = 3 using formula (6):

[0266]

[0267] Step 49: The host updates the set of base column vector indices to obtain v = [6 1 2];

[0268] Step 50: The host transmits p=3, q=2 to the OpenCL device.

[0269] Step 50.1: The OpenCL device sets the value of the fifth parameter p of the kernel object to 3;

[0270] Step 50.2: The OpenCL device sets the value of the 6th parameter q of the kernel object to 2;

[0271] Step 51: OpenCL device with y 32 =2 is the pivot element; pivot transformation is performed on the simplex tableau:

[0272] Step 51.1: The OpenCL device copies the third row of the current simplex tableau to the constant memory buffer created in step 6.2;

[0273] Step 51.2: Set the number of workgroups to 4, with 1 work item in each workgroup; each work item is responsible for updating 1 row in the simplex tableau;

[0274] Step 51.3: For each work item, perform a pivot transformation on row 1 of the simplex tableau according to formula (7). During the calculation, y 3j The value is read from the constant memory buffer created in step 6.2;

[0275] The updated simplex tableau is shown below:

[0276]

[0277] Step 52: The OpenCL device transmits the last row of the simplex tableau [0 0 1 / 2 -3 / 4 20 0 6 1 / 2] to the host;

[0278] 6th transformation

[0279] Step 53: The host checks whether all check numbers are non-negative, where Therefore, a pivot transformation is required for the simplex tableau;

[0280] Step 54: The host obtains the basic variable q = 4 from formula (5);

[0281] Step 55: The OpenCL device sets the fourth column of the simplex tableau, a4 = [0 1 / 4 1 / 2 -3 / 4]. T Transmitted to the host;

[0282] Step 56: The OpenCL device will extract the last column of the simplex tableau [1 1 1 / 2 1 / 2]. T Transmitted to the host;

[0283] Step 57: The host computer calculates the free radical variable p = 3 using formula (6):

[0284]

[0285] Step 58: The host updates the set of base column vector indices to obtain v = [6 1 4];

[0286] Step 59: The host transmits p=3, q=4 to the OpenCL device.

[0287] Step 59.1: The OpenCL device sets the value of the fifth parameter p of the kernel object to 3;

[0288] Step 59.2: The OpenCL device sets the value of the 6th parameter q of the kernel object to 4;

[0289] Step 60: OpenCL device with y 34 Using pivot elements, perform a pivot transformation on the simplex tableau:

[0290] Step 60.1: The OpenCL device copies the third row of the current simplex tableau to the constant memory buffer created in step 6.2;

[0291] Step 60.2: Set the number of workgroups to 4, with 1 work item in each workgroup; each work item is responsible for updating 1 row in the simplex tableau;

[0292] Step 60.3: For each work item, perform a pivot transformation on row 1 of the simplex tableau according to formula (7). During the calculation, y 3j The value is read from the constant memory buffer created in step 6.2;

[0293] The updated simplex tableau is shown below:

[0294]

[0295] Step 61: The OpenCL device transmits the last row of the simplex tableau [0 3 / 2 5 / 4 0 2 0 21 / 2 5 / 4] to the host;

[0296] Obtain the optimal solution

[0297] Step 62: If all the test numbers of the host are non-negative, it means that the corresponding basic feasible solution is the optimal solution.

[0298] Step 63: The OpenCL device will extract the last column of the simplex tableau [1 3 / 4 1 5 / 4]. T Transmitted to the host;

[0299] Step 64: The index of the basis column vector is v = [6 1 4], therefore the optimal solution is x. * =[3 / 4 0 0 1 0 1 0] T The objective function value is

[0300] Step 65: The host cleans up the OpenCL computing environment, releases allocated memory and related objects, and the computing ends.

[0301] Example 2:

[0302] Problem definition:

[0303] The method of this invention can be applied to various fields involving linear programming problems, such as production planning. Each product has different raw material requirements. When formulating a production plan, under the condition of satisfying the total raw material constraints, how to arrange the production quantity of each commodity to maximize the total revenue.

[0304] For example, a manufacturer produces four different products, X1, X2, X3, and X4. The production process requires three raw materials, M1, M2, and M3, with each product having different raw material requirements. When formulating a production plan, the manufacturer needs to consider the total quantities of the three raw materials, as shown in Table 1. Each production decision must satisfy these constraints. Assuming the selling prices of products X1, X2, X3, and X4 are 6 yuan, 4 yuan, 7 yuan, and 5 yuan respectively, how should the manufacturer arrange the production quantities of each product (x1, x2, x3, and x4) to maximize total revenue, while satisfying the total raw material constraints?

[0305] Table 1 Production Plan of a Manufacturer

[0306]

[0307] Referring to the data in Table 1, the system of linear constraint equations is obtained:

[0308]

[0309] The total revenue from the four products can be expressed as: f(x1,x2,x3,x4) = 6x1 + 4x2 + 7x3 + 5x4

[0310] Therefore, the original problem is to solve the following maximization problem:

[0311]

[0312] By taking the opposite values ​​of the coefficients from x1 to x4 in f(x1,x2,x3,x4), the problem of finding the maximum value is transformed into a problem of finding the minimum value. By introducing slack variables x5, x6, and x7, the optimization problem shown in formula (11) is transformed into the standard model of the optimization problem as shown in the formula, with the relevant parameters as follows:

[0313]

[0314] It is observed that the last three columns of the augmented matrix of the equation Ax = b are already a basis matrix. Therefore, the corresponding basic variables constitute a basic feasible solution. The subscript of the basis column vector is v = [5 6 7]. Therefore, we can start from this basic feasible solution and use the parallel simplex method proposed in this invention to find the optimal solution.

[0315] parameter c T The input algorithm consists of A, b, and v (i.e., step 1 of the invention), where c T Let A be the coefficient vector of the objective function of the standard linear programming problem; let A be the coefficient matrix of the constrained linear equation system; let b be the right-hand vector of the constrained linear equation system; and let v be the subscript of the basis column vectors of the constrained linear equation system. Construct the standard simplex tableau:

[0316]

[0317] The solution is obtained by following steps 1 to 20 of this invention. The process involves four parallel pivot transformations. The relevant parameters and intermediate results for each pivot transformation are shown in Table 2. After the fourth pivot transformation, all test numbers are non-negative; therefore, the optimal solution is x = [16 0 0 2]. T That is, under the current resource constraints, the manufacturer can achieve a maximum revenue of 106 yuan by producing 16 units of product X1 and 2 units of product X4.

[0318] Table 2 shows the calculation process and intermediate results of the optimization problem in Specific Implementation Method 2.

[0319]

[0320]

[0321] The innovations of this invention are reflected in the following aspects: First, the overall computational task of the simplex method is divided according to the different characteristics of the host and the device: the host completes the determination of the test number and the solution of the basis and non-basis vectors, while the computing device completes the pivot transformation. This design fully utilizes the host's strength in logical judgment and the computing device's strength in parallel execution of a large number of simple calculations. Second, based on the above task decomposition, a reasonable data transmission strategy between the host and the device is designed to maintain a small data transmission volume (1 row + 2 columns of the simplex tableau) during each round of pivot transformation, further improving the efficiency of parallel computing. Third, on the computing device, a parallel computing method for implementing the pivot transformation is designed. Before each round of pivot transformation, the p-th row of the simplex tableau is copied to the constant storage area, making full use of the performance advantage of the constant storage area of ​​the parallel computing device. At the same time, the pivot transformation on the entire simplex tableau is distributed to multiple work items on the computing device, further improving the execution efficiency of the algorithm.

[0322] The above description is only a preferred embodiment of the present invention. It should be noted that for those skilled in the art, several improvements and modifications can be made without departing from the technical principles of the present invention, and these improvements and modifications should also be considered within the scope of protection of the present invention.

Claims

1. A method for solving large-scale linear programming problems based on heterogeneous computing, characterized in that, The method includes the following steps: Step 1: Calculate the relevant parameters in the standard linear programming model. Input the data into the computer, and also provide the initial set of basis column vector indices. ; Step 2: The host initializes the OpenCL heterogeneous computing environment, in which the host reads and parses the pivot transformation module; Step 3: The host computer constructs the simplex tableau for the linear programming problem according to formula (2); Step 4: The host checks whether the basis matrix is ​​invertible. If the basis matrix is ​​invertible, proceed to the next step; otherwise, the linear programming problem has no solution, and the algorithm ends. Step 5: The host computer converts the simplex tableau obtained in Step 3 into a standard simplex tableau according to formulas (3) and (4): Step 6: The host requests memory space from the OpenCL device; Step 6.1: The OpenCL device creates a buffer in global memory according to the size of the standard simplex table; Step 6.2: The OpenCL device creates a buffer in constant memory according to the size of 1 row of the standard simplex table; Step 7: The host requests the creation of a kernel object from the OpenCL device and sets the parameters according to the pivot transformation module. The parameters of the kernel object are the same as those of the pivot transformation module. Step 8: The host transfers the standard simplex table to the OpenCL device, specifically to the global memory buffer created in step 6.1; Step 9: The host checks whether all test numbers are non-negative; if all test numbers are non-negative, it means that the solution corresponding to the current basis column vector is the optimal solution, and proceeds to step 18; otherwise, proceed to the next step. Step 10: The host computer calculates the base variable according to formula (5). ; Step 11: The OpenCL device will update the simplex tableau. The column is transferred to the host; Step 12: The OpenCL device transmits the last column of the updated simplex tableau to the host; Step 13: The host computer calculates the free radical variable according to formula (6). ; Step 14: Update the set of base column vector indices on the host machine. ,make ; Step 15: The host will Transmitted to OpenCL device; Step 16: OpenCL device with The positional elements are pivot elements, and parallel pivot transformations are performed on the simplex tableau; Step 17: The OpenCL device transmits the last row of the updated simplex tableau to the host; proceed to step 9; Step 18: The OpenCL device transmits the last column of the updated simplex tableau to the host; Step 19: The host obtains the optimal solution from the last column of the standard simplex tableau according to the position of the current basis column vector; Step 20: The host cleans up the OpenCL computing environment, releases allocated memory and related objects, and the computing ends; in, The standard model for linear programming problems is: （1） in, The coefficient vector of the objective function. To constrain the coefficient matrix of the linear equation system, To constrain the right-hand vector of the system of linear equations, As decision variables, , , , , ; The process of solving linear programming problems using the simplex method is as follows: S1, Order The former The columns are basis vectors, and these basis vectors form the basis matrix. The remaining column vectors form a non-basic matrix. ; S2, Order The former Each component is a component corresponding to a basis vector, denoted as a vector. The remaining components form a vector. ; S3. Construct the simplex tableau from the standard model of the linear programming problem shown in formula (1): （2） S4. Multiply the matrix on the right side of equation (2) by the left side. The augmented matrix in the simplex tableau Transform to normal form: （3） in for Unit matrix of order, Basis matrix The inverse matrix; if If it does not exist, then the linear programming problem has no solution; S5. Multiply the matrix on the right side of equation (3) by the left side. Change the elements in the last row of the matrix on the right-hand side of equation (3) that correspond to the basis column vectors to zero: （4） In formula (4), the matrix on the right-hand side of the equal sign is called the matrix of the linear programming problem with respect to the basis. The standard simplex tableau, in which: a) In the last column of the standard simplex tableau, the first... element It is about The basic variables; b) In the last row of the standard simplex tableau, it is called The test number is denoted as . , The negative of the objective function value for the current basic feasible solution; S6. If all test numbers If the solution is found to be feasible, the calculation stops, and the current basic feasible solution is the optimal solution; otherwise, proceed to the next step. S7. Calculate the indices of the in-basic column vector and the out-of-basic row vector according to formulas (5) and (6) respectively, where The index of the entering basis column vector. The subscript of the off-basic row vector: （5） （6） in Representing the simplex table Elements at the location; In the last column of the simplex tableau The The values ​​of the basic variables; S8, with As pivot elements, the simplex tableau is pivoted according to formula (7): （7） in For the transformed simplex table The element at that location; proceed to step S6.

2. The method for solving large-scale linear programming problems based on heterogeneous computing as described in claim 1, characterized in that, Step 2 specifically includes: Step 2.1: Obtain the heterogeneous computing platform ID on the current computer; Step 2.2: Obtain the device ID on the current heterogeneous computing platform; Step 2.3: Create a heterogeneous computing environment context object using the device ID on the current heterogeneous computing platform; Step 2.4: Create a command queue using the heterogeneous computing environment context object. The host sends commands to the OpenCL device through the command queue. Step 2.5: The host reads and parses the pivot transformation module.

3. The method for solving large-scale linear programming problems based on heterogeneous computing as described in claim 2, characterized in that, The pivot transformation module contains six input parameters: mat, row_p, n_row, n_col, p, and q. mat is an array storing the standard simplex tableau, located in global memory; row_p is an array storing the p-th row of the simplex tableau, located in constant memory; n_row is the number of rows in the simplex tableau, a positive integer; n_col is the number of columns in the simplex tableau, a positive integer; p is the pivot transformation parameter; and q is the pivot transformation parameter.

4. The method for solving large-scale linear programming problems based on heterogeneous computing as described in claim 3, characterized in that, The pivot transformation module is responsible for performing parallel pivot transformations on the simplex tableau on the device according to formula (7).

5. The method for solving large-scale linear programming problems based on heterogeneous computing as described in claim 3, characterized in that, Step 2.5 specifically includes the following steps: Step 2.5.1: Obtain the current work item number, denoted as... ; Step 2.5.2: Obtain the simplex tableau from mat. line, number Column elements, denoted as ; Step 2.5.3: Obtain the first row of row_p There are n elements, denoted as n. ; Step 2.5.4: Calculation ; Step 2.5.5: Let ; Step 2.5.6: Check if and If yes, proceed to step 2.5.7; otherwise, the module call ends. Step 2.5.7: Check if If yes, proceed to step 2.5.8; otherwise, proceed to step 2.5.

9. Step 2.5.8: Calculation Proceed to step 2.5.11; Step 2.5.9: Obtain the first row of row_p There are n elements, denoted as n. ; Step 2.5.10: Calculation Proceed to step 2.5.11; Step 2.5.11: Proceed to step 2.5.

6.

6. The method for solving large-scale linear programming problems based on heterogeneous computing as described in claim 5, characterized in that, Step 7 specifically includes the following steps: Step 7.1: The OpenCL device creates a kernel object kernel(mat, row_p, n_row, n_col, p, q), where p and q are pivot transformation parameters, which will be given in subsequent step 15; Step 7.2: The OpenCL device sets the first parameter mat of the kernel object to the global memory buffer created in step 6.1; Step 7.3: The OpenCL device sets the second parameter row_p of the kernel object to the constant memory buffer created in step 6.2; Step 7.4: The OpenCL device sets the third parameter n_row of the kernel object to the number of rows in the standard simplex tableau; Step 7.5: The OpenCL device sets the fourth parameter n_col of the kernel object to the number of columns in the standard simplex tableau.

7. The method for solving large-scale linear programming problems based on heterogeneous computing as described in claim 6, characterized in that, Step 15 specifically includes the following steps: Step 15.1: The OpenCL device sets the value of the fifth parameter p of the kernel object to... ; Step 15.2: The OpenCL device sets the value of the 6th parameter q of the kernel object to... .

8. The method for solving large-scale linear programming problems based on heterogeneous computing as described in claim 7, characterized in that, Step 16 specifically includes the following steps: Step 16.1: The OpenCL device will display the current simplex tableau's first... Rows are copied into the constant memory buffer created in step 6.2; Step 16.2: Based on the relevant information of the OpenCL device, determine the values ​​of the relevant parameters for performing parallel computing; Step 16.3: The OpenCL device creates relevant workgroups and work items. Each work item performs a pivot transformation on row 1 of the simplex tableau according to formula (7); where the required first row... The data for the row is read from the constant memory buffer created in step 6.

2.

9. The method for solving large-scale linear programming problems based on heterogeneous computing as described in claim 8, characterized in that, In step 16.2, the relevant parameters include: the number of work groups and the number of work items.

10. The method for solving large-scale linear programming problems based on heterogeneous computing as described in claim 1, characterized in that, This method is used in the field of production planning.

Images