Multi-frontal layered iteration parallel computing method and device for tidal current sparse equation

Abstract

This invention relates to a hierarchical iterative parallel computation method and apparatus for sparse power flow equations with multiple front edges. The method includes: allocating different amounts of computational resources to each branch and node of the parallel hierarchical elimination tree of the Jacobian matrix based on its structural characteristics; performing submatrix computation on nodes in parallel from lower-level nodes to upper-level nodes, taking the branches under the root node of the parallel hierarchical elimination tree as units; storing the Jacobian submatrices obtained from the submatrix computation, and storing the LU decomposition of the node dense submatrices and contribution submatrices obtained from the submatrix LU decomposition; superimposing the contribution submatrices calculated by the lower-level nodes onto the corresponding nodes in the upper level, and synchronously updating the data in the Jacobian submatrices. This invention can accelerate the efficiency of power flow equation matrix decomposition and improve the effectiveness of power flow computation.

Description

Technical Field

[0001] This invention relates to the field of power flow calculation technology, and in particular to a hierarchical iterative parallel calculation method for power flow sparse equations with multiple frontiers. Background Technology

[0002] Power flow calculation is a crucial analytical calculation for power systems. Based on the power system's wiring configuration, parameters, and operating conditions, it calculates the electrical quantities under steady-state operation, including active power, reactive power, and voltage distribution within the grid. Power flow calculation is also fundamental for system safety, stability, and reliability analysis, used to study various issues arising during system planning and operation. For planned power systems, power flow calculation can verify whether the proposed power system plan meets the requirements of various operating modes. For operating power systems, it can predict whether various load changes and network structure alterations will jeopardize system safety, whether the voltage of all buses in the system is within permissible ranges, whether various components in the system (lines, transformers, etc.) will experience overload, and what preventative measures should be taken in advance if overloads occur.

[0003] Existing literature (Nwankpa C, Johnson J, Nagvajara P, et al. FPGA hardware results for power system computation[C] / / 2009 IEEE / PES Power Systems Conference and Exposition.0[2023-09-26].DOI:10.1109 / PSCE.2009.4839953.) proposes an FPGA system for power flow computation based on the Newton-Raphson method by collecting data from real-time SCADA system networks and telemetry transmissions. The solution strategy for the linear equation system is the matrix LU decomposition method, which adopts a PCI pipeline bus architecture and uses FPGA hardware to reduce pivot search time and accelerate LU decomposition.

[0004] This scheme uses the Newton-Raphson method to solve power flow problems, employing a conventional serial approach for calculating the matrix decomposition of sparse power flow equations. However, power flow calculations in power systems typically require both timeliness and accuracy, often involving networks with dimensions reaching thousands of dimensions. When dealing with power flow calculations in large-scale power grids, especially in situations with high timeliness requirements, this approach suffers from computational delays and low timeliness, failing to meet the power grid's demands for fast response and high accuracy in power flow calculations. Summary of the Invention

[0005] The technical problem to be solved by the present invention is to provide a hierarchical iterative parallel computing method and apparatus for power flow sparse equations with multiple frontiers, which can improve the efficiency of power flow computing.

[0006] The technical solution adopted by this invention to solve its technical problem is: to provide a hierarchical iterative parallel computation method for sparse power flow equations with multiple front edges, comprising the following steps:

[0007] Based on the structural characteristics of the parallel hierarchical elimination tree of the Jacobian matrix, different amounts of computing resources are allocated to each branch and each node of the parallel hierarchical elimination tree of the Jacobian matrix.

[0008] Based on the allocated computing resources, submatrix calculations are performed on nodes in parallel from lower-level nodes to upper-level nodes, taking the branches under the root node of the Jacobian matrix parallel hierarchical elimination tree as the unit.

[0009] Store the Jacobian submatrix obtained by submatrix calculation, and store the LU decomposition of the node dense submatrix and the contribution submatrix obtained by submatrix LU decomposition.

[0010] The contribution submatrix calculated by the lower-level nodes is superimposed on the corresponding nodes in the upper level, and the data in the Jacobi submatrix is ​​updated synchronously.

[0011] The method involves allocating different amounts of computational resources to each branch and node of the parallel hierarchical elimination tree of the Jacobian matrix based on its structural characteristics. This includes a forward search processing stage and a backward search processing stage. The forward search processing stage searches downward from the root node of the parallel hierarchical elimination tree of the Jacobian matrix to estimate the number of node submatrix computational resources allocated to all nodes of the parallel hierarchical elimination tree of the Jacobian matrix. The backward search processing stage searches upward from the last node of the parallel hierarchical elimination tree of the Jacobian matrix to perform node submatrix computational resource numbering and resource quantity correction.

[0012] The forward search processing stage specifically includes:

[0013] If the root node's address pointer is not null, repeat the following process:

[0014] Search each node in the hierarchical elimination tree sequentially, obtain the child node numbers of the root node, and save them to the child node count register;

[0015] Determine if the current root node is a supernode. If the current root node is not a supernode, record the resources required by the current root node and save the value in the child node count register to the node resource allocation register. If the current root node is a supernode, save the starting node address of the supernode from the supernode linked list according to the current root node number to the supernode address register.

[0016] Traverse all supernodes and repeat the following process: retrieve the current supernode number from the supernode number register and save it to the supernode number register; save the value in the supernode number register to the node resource register; retrieve the address of the next supernode from the supernode pointer register and save it to the supernode address register.

[0017] Complete the resource allocation for the current root node, proceed to the next node search, save the currently found root node number to the leaf node number register, save the current root node address to the leaf node address register, and update the value in the root node address register to the address pointer of the next root node.

[0018] The reverse search processing stage specifically includes:

[0019] In the forward search processing stage, the resource allocation address of the leaf node found is pointed to the cell address where the new resource is to be inserted. The newly added resource allocation address is connected to the node resource allocation list at the current leaf node number. The resource quantity register required by the node at the current address is updated.

[0020] Determine the number of child nodes of the parent node of the current node, save the address of the parent node of the current leaf node from the parent node register to the parent node address register, and retrieve the number of child nodes of the parent node from the child node count register and save it to the parent node child node count register.

[0021] While the value in the parent node's address register is not empty, the following process is executed repeatedly:

[0022] Set the node resource allocation address pointer register at the current leaf node address to the cell address where the new resource is to be inserted, and save the offset address of the current leaf node linked list to the starting address register of the resource required by the current node;

[0023] Find the resource ID of the child node of the current leaf node, retrieve the number of child nodes of the leaf node, and save it to the leaf node's child node count register. Retrieve the starting address of the child node from the child node linked list address pointer linked list register and save it to the leaf node's child node address register. Traverse all child nodes of the leaf node and repeat the following first sub-process:

[0024] The first sub-process includes:

[0025] Retrieve the child node number and save it to the child node number register of the leaf node. Then, find the resource allocation number of each child node in turn. Save the starting address of the current child node's resource allocation to the child node resource address register of the leaf node, and save the resource quantity of the child node to the child node resource quantity register of the leaf node. Iterate through each resource of the child node and repeat the following second sub-process:

[0026] The second sub-process includes:

[0027] Write the value in the child node number register of the leaf node to the resource number register at the parent node address; save the starting address of the resource required by the current node to the address pointer register of the previous resource; update the starting address of the resource required by the current node to the cell address of the new resource to be inserted; increment the address pointed to by the address pointer register of the next resource of the current node by 1;

[0028] Find the address of the next child node of the leaf node and save it to the child node address register of the leaf node, thus completing the resource numbering of the child nodes of all leaf nodes;

[0029] Update the search order, continue searching to the parent node of the current leaf node, save the parent node number of the current leaf node from the parent node number register to the leaf node number register, and save the parent node address of the current node to the parent node address register.

[0030] The submatrix calculation of the nodes includes column element calculation, which specifically includes:

[0031] Save the address of the non-zero element in the first row of the submatrix linked list of the i-th node to the submatrix row number address register. Save the number of non-zero elements in the submatrix of the i-th node from the column element count register to the dimension register of the i-th node. Then save the value in the dimension register of the i-th node as the dimension of the submatrix to the submatrix dimension register.

[0032] Retrieve the first address of the i-th node's column list from the Jacobian matrix column list address pointer register and save it to the column node address register; retrieve the address of the first non-zero element of the first column of the lower triangular matrix L decomposed from the i-th child node from the lower triangular matrix address pointer register and save it to the lower triangular matrix L column address register; save the address of the submatrix of the i-th node to the Jacobian submatrix address register;

[0033] Iterate through the dimensions of the submatrix, repeating the following process:

[0034] Set the memory read / write burst length, pull the memory read valid signal high, set the read data counter to a cyclic count of 1, 2, 3, perform a memory read operation from the address of the first element of the current node column stored in the column node address register, save the data to the data bus, and save the data on the data bus to the sub-matrix data register when the value of the read data counter is 1 and 2 respectively.

[0035] Save the column element row number value at the address in the column node address register to the submatrix row number register;

[0036] Save the write address of the current Jacobi submatrix data to the Jacobi data address register; save the first column data of the Jacobi submatrix to the submatrix cell pointed to by the address in the Jacobi data address register, record the row number of the Jacobi submatrix data, save the submatrix row number to the submatrix node row number register, and point the column element address pointer of the current matrix to the next non-zero element and save it to the column node address register;

[0037] The row numbers of the lower triangular matrix L are stored in the submatrix node row number register. The address of the submatrix row node number of the i-th node is the value in the submatrix row number address register. The value in the submatrix dimension register is saved to the dimension register. The write address of the lower triangular matrix L is located as the value in the lower triangular matrix L column address register. The Jacobian submatrix data is written to the lower triangular matrix L data register. The Jacobian submatrix row numbers are written to the row register of the lower triangular matrix L. The write address of the lower triangular matrix L is shifted down one unit.

[0038] After completing the traversal, the column data of the Jacobi submatrix of the i-th node is obtained, and the first column of the Jacobi submatrix is ​​written into the first column of the lower triangular matrix L;

[0039] Update the column address pointer register of the lower triangular matrix L so that it points to the write address of the next column data.

[0040] The submatrix calculation of the nodes includes row element calculation, which specifically includes:

[0041] Retrieve the address of the first element of the i-th row from the row address pointer register of the upper triangular matrix U and store it in the row address register of the upper triangular matrix U; initialize the node data counter and store the number of row elements of the i-th node in the row element count register. When the value of the node data counter is less than the value in the row element count register, repeat the following process:

[0042] Save the starting row address of the i-th node to the row node address register, set the memory read / write burst length, and pull the memory read valid signal high; set the read data counter to count in a loop of 1, 2, and 3, perform a memory read operation from the address of the first element of the current node's row stored in the row node address register, save the data to the data bus, save the data on the data bus to the submatrix data register when the read data counter value is 1 and 2, and save the data on the data bus to the Jacobi submatrix column label register when the read data counter value is 3;

[0043] Save the column index value of the target column of the current submatrix to the target column register. If the submatrix column index value is the same as the value in the target column register, execute the following process:

[0044] Save the starting address of the Jacobi submatrix plus the offset address of the Jacobi submatrix data to be written to the Jacobi data address register, and write the Jacobi submatrix data to the submatrix pointed to by the Jacobi data address register;

[0045] The column number of the first row of data written to the upper triangular matrix U is stored in the submatrix row node number register. The write address of the upper triangular matrix U is located as the value in the row address register of the upper triangular matrix U. The Jacobi submatrix data is written to the data register of the upper triangular matrix U. The Jacobi submatrix column number is written to the column register of the upper triangular matrix U. The write address of the upper triangular matrix U is shifted down one unit.

[0046] After completing the above process, the row data of the Jacobi submatrix of the i-th node is obtained, and the first row of the Jacobi submatrix is ​​written into the first row of the upper triangular matrix U.

[0047] Update the row offset address pointer register of the upper triangular matrix U so that it points to the next row write address.

[0048] The process of storing the Jacobian submatrix obtained from the submatrix calculation, and storing the LU decomposition of the node dense submatrix and the contribution submatrix obtained from the LU decomposition of the submatrix, specifically involves: setting a node submatrix address register to store the storage address of each node submatrix; setting a submatrix storage linked list for each child node to store the intermediate submatrix decomposition results during the calculation process, wherein the submatrix storage linked list includes a dense submatrix register, an LU decomposition register, and a contribution submatrix register; wherein, the dense submatrix contains three auxiliary registers, the first and second auxiliary registers respectively store the row index and column index values ​​of the non-zero rows in the current column of the dense submatrix, and the third auxiliary register stores the dimension of the dense submatrix; the LU decomposition register stores the result of LU decomposition of each node, and the contribution submatrix register stores the contribution matrix of the current node to other nodes in the upper layer.

[0049] The step of superimposing the contribution submatrix calculated by the lower-level nodes onto the corresponding nodes in the upper level, and synchronously updating the data in the Jacobi submatrix, specifically includes:

[0050] Iterate through all rows and columns of the contribution submatrix, repeating the following process:

[0051] The storage address of the contribution submatrix is ​​saved to the contribution submatrix address register, and then the contribution submatrix data is retrieved from the contribution submatrix address in the LU submatrix register and saved to the contribution submatrix data register;

[0052] Retrieve the corresponding contribution submatrix row number and column number from the Jacobi submatrix row number register and save them to the Jacobi row register and Jacobi column register, respectively;

[0053] The values ​​in the contribution submatrix data register are superimposed onto the cells pointed to by the Jacobi row register and the Jacobi column register; the address of the first non-zero element of the row number corresponding to the value in the Jacobi row register is saved from the Jacobi row address pointer register to the Jacobi row address register, and the column number at the address in the Jacobi row address register is saved to the Jacobi column number register.

[0054] Save the number of row elements at the address in the Jacobian row address register to the Jacobian row element count register;

[0055] Initialize the Jacobian element count counter. When the value in the Jacobian column number register is not equal to the value in the Jacobian column register, and the value of the Jacobian data element count counter is less than the value in the Jacobian row element count register, execute the following procedure:

[0056] Update the current Jacobian row address register, save the column number of the next Jacobian element in the current row to the Jacobian column number register, and update the Jacobian element count counter.

[0057] At the address in the Jacobi row address register, retrieve historical data from the Jacobi data register and save it to the Jacobi historical data register. Add the value of the contribution submatrix to the current Jacobi matrix and save the new value to the new Jacobi data register. Save the value in the new Jacobi data register to the Jacobi data register.

[0058] The technical solution adopted by this invention to solve its technical problem is: to provide a hierarchical iterative parallel computing device for sparse power flow equations with multiple front edges, comprising:

[0059] The node resource allocation calculation module is used to allocate different amounts of computing resources to each branch and each node of the parallel hierarchical elimination tree of the Jacobian matrix according to the structural characteristics of the Jacobian matrix parallel hierarchical elimination tree.

[0060] The node submatrix parallel decomposition module is used to perform submatrix calculations on nodes in parallel from lower-level nodes to upper-level nodes, based on the allocated computing resources and taking the branches under the root node of the Jacobian matrix parallel hierarchical elimination tree as the unit.

[0061] The Jacobi submatrix linked list calculation module is used to store the Jacobi submatrix obtained by submatrix calculation, and to store the LU decomposition of the node dense submatrix and the contribution submatrix obtained by the LU decomposition of the submatrix.

[0062] The overlay calculation module is used to overlay the contribution submatrix calculated by the lower-level nodes onto the corresponding nodes in the upper level, and synchronously update the data in the Jacobi submatrix.

[0063] The technical solution adopted by the present invention to solve its technical problem is: to provide an FPGA-based power flow parallel computing system, including the above-mentioned multi-front-edge power flow sparse equation hierarchical iterative parallel computing device.

[0064] The technical solution adopted by the present invention to solve its technical problem is: to provide a computer-readable storage medium on which a computer program is stored, wherein when the computer program is executed by a processor, the steps of the above-mentioned hierarchical iterative parallel calculation method for the power flow sparse equation of multiple frontier surfaces are implemented.

[0065] Beneficial effects

[0066] By adopting the above-mentioned technical solution, this invention has the following advantages and positive effects compared with the prior art: This invention allocates different amounts of computing resources to each branch and each node, and then, based on the allocated computing resources, performs submatrix calculations on the node submatrix in parallel from the lower-level node to the upper-level node. Based on the calculation results, the contribution submatrix calculated by the lower-level node is superimposed on the corresponding node in the upper level, and the Jacobian matrix is ​​updated synchronously. This method can achieve the highest parallel execution degree when solving the sparse equations of power flow in large-scale networks, accelerate the calculation time of traditional matrix decomposition, reduce the time of solving the equations in the serial manner, accelerate the efficiency of power flow equation matrix decomposition, and improve the effectiveness of power flow calculation. Attached Figure Description

[0067] Figure 1 This is a flowchart of the hierarchical iterative parallel computation method for power flow sparse equations with multiple frontiers according to the first embodiment of the present invention;

[0068] Figure 2 This is a schematic diagram of the hierarchical relationship of the parallel computation nodes of the equation system with multiple front surfaces in the first embodiment of the present invention;

[0069] Figure 3 This is a schematic diagram of the node submatrix LU decomposition and contribution matrix linked list structure in the first embodiment of the present invention;

[0070] Figure 4 This is a schematic diagram of the superposition of the node contribution submatrix with the upper-level nodes in the first embodiment of the present invention;

[0071] Figure 5 This is a diagram showing the correspondence between the LU decomposition results of the node submatrix and the Jacobian LU decomposition in the first embodiment of the present invention;

[0072] Figure 6 This is a flowchart of the computational resource allocation for submatrix nodes in the first embodiment of the present invention;

[0073] Figure 7 This is a schematic diagram of the linked list storage structure for node resource allocation in the first embodiment of the present invention;

[0074] Figure 8 This is a block diagram of a hierarchical iterative parallel computing device for power flow sparse equations with multiple frontiers according to the second embodiment of the present invention.

[0075] Figure 9 This is a schematic diagram of a power flow parallel computing system based on FPGA according to the third embodiment of the present invention. Detailed Implementation

[0076] The present invention will be further illustrated below with reference to specific embodiments. It should be understood that these embodiments are for illustrative purposes only and are not intended to limit the scope of the invention. Furthermore, it should be understood that after reading the teachings of this invention, those skilled in the art can make various alterations or modifications to the invention, and these equivalent forms also fall within the scope defined by the appended claims.

[0077] The first embodiment of the present invention relates to a hierarchical iterative parallel computation method for power flow sparse equations with multiple front edges, such as... Figure 2 As shown, this method allocates resources to each node in the parallel hierarchical elimination tree that generates the original Jacobian matrix. The subtrees formed by all descendant nodes of the root node can be computed in parallel (within the box). All descendant child branches of the same node are assigned to the same submatrix computation module (sub_matrix_compute, SMC). After the computation within the solid box is completed, the matrix decomposition is iteratively calculated layer by layer from the end node upwards, and the contribution results are gradually accumulated to the root node of the upper layer. The circles represent supernodes with the same structure. Finally, the decomposition of the entire Jacobian matrix is ​​completed, which speeds up the solution speed of power flow calculation.

[0078] In this implementation of the parallel hierarchical elimination tree for the Jacobian matrix, the first step is to determine the branches formed by all descendant nodes of each root node and allocate resources in parallel. Within each submatrix calculation module, the matrix decomposition of nodes in each branch set is calculated independently. After each node's calculation is complete, the contribution value of the current node to other nodes at the upper level is accumulated and added to the corresponding node. At the root node, a judgment is made. After all branches have been calculated, the contribution values ​​of the submatrixes calculated at the lower level are superimposed. Each node in the tree represents a dense submatrix, which is composed of all non-zero columns of the Jacobian matrix in the column where the node's number is located, denoted as sub_jacoby_matrix. Figure 1 As shown, this embodiment specifically includes the following steps:

[0079] Step 1: Based on the structural characteristics of the parallel hierarchical elimination tree of the Jacobian matrix, allocate different amounts of computing resources to each branch and each node of the parallel hierarchical elimination tree of the Jacobian matrix.

[0080] The resource allocation process in this implementation includes a forward search processing stage and a reverse search processing stage. First, the search proceeds from the root node downwards. Each time a lower-level node is encountered that is also the root node, the nodes in the subtree formed by all the descendant nodes of the root node need to be allocated to the submatrix calculation module SMC. The number of independent submatrix calculation modules required is equal to the number of the lowest-level subtrees in the hierarchical elimination tree.

[0081] The `node_SMC_id` register stores the submatrix calculation module (SMC) number allocated to each node in the tree. The terminal nodes in the hierarchical elimination tree consume fewer computational resources, allowing for the calculation of dense submatrices with less resource allocation. As the calculation progresses upwards from the root node, the contributions of each lower-level node to the upper-level node need to be accumulated. When the root node is reached, the calculation is completed jointly by the computational resources of all child nodes and subtrees of the root node.

[0082] like Figure 6 As shown, based on the block structure of the matrix and the number of nodes in each submatrix, and according to the structural characteristics of the parallel hierarchical elimination tree of the Jacobian matrix, different amounts of computing resources are allocated to each branch and each node. The submatrix computation module (SMC) number is stored in the node resource allocation linked list, and the corresponding submatrix block data is allocated to the corresponding computation module for parallel computation. The computational task size in the hierarchical elimination tree gradually increases from the lower-level nodes to the upper-level nodes. When the root node in the hierarchical elimination tree is computed, the required computing resources are the sum of all branches. The specific implementation process is as follows:

[0083] The `node_resource` register stores the number of submatrix computation module resources required for each node. The search begins with the root node's `root_node_id`. First, the address of the root node is retrieved from the `head_child_id` register, and then saved to the `root_node_addr` register (where `root_node_addr` ≠ `head_child_id` [`root_node_id`]. The process is divided into a forward search phase and a reverse search phase. The forward search phase searches downwards from the root node of the Jacobian matrix parallel hierarchical elimination tree to estimate the number of submatrix computation resources needed for all nodes in the tree. The reverse search phase searches upwards from the last node of the Jacobian matrix parallel hierarchical elimination tree to allocate submatrix computation resources and correct the resource quantity.

[0084] The forward search processing phase is as follows:

[0085] When the address pointer of the root node is not null, i.e., root_node_addr ≠ null, the following process is repeated:

[0086] Search each node in the hierarchy in sequence, obtain the child node number of the root node and save it to the child node count register root_child_num, that is, root_child_num←num_child[root_node_id].

[0087] To determine whether the current root node root_node_addr is a supernode, retrieve the supernode identifier of the current node from the supernode identifier register super_node_num and save it to the sub_node_num register, i.e., sub_node_num ← super_node_num [root_node_id], and then determine whether it is a supernode.

[0088] If the supernode identifier is 0, i.e., sub_node_num=0, it means that the current root node is not a supernode. Record the resources required by the current root node and save the value in the child node count register to the node resource allocation register node_resource, i.e., node_resource[root_node_id]←root_child_num.

[0089] If the supernode identifier is greater than 0, i.e., sub_node_num > 0, it indicates that the current root node is a supernode, and resource allocation is performed on all nodes in the supernode set. The starting address of the supernode is saved from the supernode linked list super_node according to the current root node number root_node_id into the supernode address register sub_node_addr, i.e., sub_node_addr ← super_node[root_node_id].

[0090] Set the supernode counter cnt_sub_node from 1 to the number of supernodes sub_node_node, traverse all supernodes, and repeat the following process:

[0091] Retrieve the current supernode number from the supernode number register sup_node_id and save it to the supernode number register sub_node_id, i.e., sub_node_id ← sup_node_id [sub_node_addr]. Save the value in the supernode number register to the node resource register node_resource, i.e., node_resource [sub_node_id] ← sub_node_id. Retrieve the address of the next supernode from the supernode pointer register subnode_down_ptr and save it to the supernode address register sub_node_addr, i.e., sub_node_addr ← subnode_down_ptr [sub_node_addr].

[0092] The resource allocation for the current root node has been completed. The search then moves to the next node, saving the current root node number (root_node_id) to the leaf node number register (leaf_node_id), i.e., leaf_node_id ← root_node_id. The current root node address (root_node_addr) is saved to the leaf node address register (leaf_node_addr), i.e., leaf_node_addr ← root_node_addr. The root node address register (root_node_addr) is then updated, i.e., root_node_addr ← down_ptr[root_node_addr]. The loop ends when the value in the root node address register (root_node_addr) is empty; otherwise, the loop continues.

[0093] After the above process is completed, the estimated number of resources allocated to all nodes in the hierarchical elimination tree has been completed. The next step is to start the reverse search processing stage from the current last node.

[0094] The reverse search processing phase is as follows:

[0095] When the address pointer of the root node in the forward search processing phase is null (i.e., root_node_addr=null), the reverse search processing phase begins, starting from the last leaf node and searching upwards layer by layer, calculating the resource number value and the correction value of the resource quantity for each node.

[0096] like Figure 7 As shown, the register node_SMC_num[31:0][2(n-1)-1:0] represents the number of resources allocated to each node, node_SMC_id represents the address pointer register of the resource allocation linked list for each node, the first address of the linked list is the value in the register node_SMC_addr, and the data unit of each resource in the linked list consists of three parts: the address pointer registers SMC_up_ptr and SMC_down_ptr represent the address pointers of the previous and next resources of the current resource, respectively; the SMC_id register represents the current resource number; and the current_SMC_addr register represents the cell address of the linked list where the new resource is to be inserted.

[0097] In the forward search processing phase, the resource allocation address of the leaf node leaf_node_addr found is pointed to the cell address current_SMC_addr where the new resource is to be inserted, i.e., node_SMC_id[leaf_node_addr]←current_SMC_addr. The newly added resource allocation address is then linked to the node resource allocation linked list node_SMC_id at the current leaf node number leaf_node_id, with an offset address of node_SMC_addr+leaf_node_id, SMC_up_ptr[current_SMC_addr]←nodeSMC_addr+leaf_node_id. The resource quantity register SCM_id required by the node at the current address is updated, i.e., SMC_id[current_SMC_addr]←SMC_id[current_SMC_addr]+1.

[0098] Determine the number of child nodes of the current node's parent node. Save the address of the parent node of the current leaf node from the parent node register parent_id to the parent node address register parent_node_addr, i.e., parent_node_addr←parent_id[leaf_node_addr]. Take the number of children of the parent node from the child node count register num_child and save it to the parent node's child node count register parent_child_num, i.e., parent_child_num←num_child[parent_node_id].

[0099] While the value in the parent_node_addr register is not empty, the following process is executed repeatedly:

[0100] The node resource allocation address pointer register node_SMC_id at the current leaf node address is set to point to the cell address current_SMC_addr where the new resource is to be inserted, i.e., node_SMC_id[leaf_node_addr]←current_SMC_addr. The offset address of the current leaf node linked list node_SMC_addr+leaf_node_id is saved to the starting address register SMC_start_addr of the resource required by the current node, i.e., SMC_start_addr←node_SMC_addr+leaf_node_id.

[0101] Find the resource SMC number of the child node of the current leaf node. First, retrieve the number of child nodes of the leaf node and save it to the leaf node's child node count register leaf_child_num, i.e., leaf_child_num ← num_child[leaf_node_id]. From the child node linked list address pointer linked list register head_child_id, retrieve the starting address of the leaf node's child node and save it to the leaf node's child node address register leaf_child_addr, i.e., leaf_child_addr ← head_child_id[leaf_node_id]. Set the child node count counter cnt_child_num from 1 to leaf_child_num, and traverse all child nodes of the leaf node, repeating the following sub-process 1:

[0102] Sub-process 1: Retrieve the child node number and save it to the leaf node's child node number register `leaf_child_id`, i.e., `leaf_child_id ← child_id [leaf_child_addr]`. Then, find the resource allocation number of each child node in turn. Save the starting address of the current child node's node resource allocation to the leaf node's child node resource address register `leaf_child_SMC_addr`, i.e., `leaf_child_SMC_addr ← node_SMC_id [leaf_child_id]`. Save the number of resources of this child node to the leaf node's child node resource quantity register `leaf_child_SMC_num`, i.e., `leaf_child_SMC_num ← node_SMC_num [leaf_child_id]`. For each resource of this child node, search for the resource number and set the resource counter `cnt_SMC_num` from 1 to the total number of child node resources `leaf_child_SMC_num`. Repeat the following sub-process 2:

[0103] Sub-process 2: Write the value in the leaf_child_SMC_id register of the leaf node to the resource number register SMC_id at the parent node's address current_SMC_addr, i.e., SMC_id[current_SMC_addr]←leaf_child_SMC_id. Save the starting address SMC_start_addr of the resource required by the current node to the address pointer register SMC_up_ptr of the previous resource, i.e., SMC_up_ptr[current_SMC_addr]←SMC_start_addr, and then update the current address current_SMC_addr to the new starting address, i.e., SMC_start_addr←current_SMC_addr. Increment the address pointed to by the next resource address pointer register SMC_down_ptr of the current node by 1, i.e., SMC_down_ptr[current_SMC_addr]←current_SMC_addr+1. At this point, the resource numbering for the first child is complete, and sub-process 2 ends.

[0104] Next, the address of the next child node of the leaf node is found and saved to the leaf node's child node address register, leaf_child_addr, i.e., leaf_child_addr←down_ptr[leaf_child_addr]. At this point, the resource numbering of all child nodes of the leaf nodes is complete, and sub-process 1 ends.

[0105] Then, the search order is updated, and the search continues to the parent node of the current leaf node. The parent node number of the current leaf node is saved from the parent node number register parent_id to the leaf node number register leaf_node_id, that is, leaf_node_id←parent_id[leaf_node_id]. At the same time, the parent node address of the current node is saved to the parent node address register parent_node_addr, that is, parent_node_addr←parent_id[leaf_node_id].

[0106] Thus, the resource allocation for all nodes in the hierarchical elimination tree has been completed through the above forward search and reverse search processing stages.

[0107] Step 2: Based on the allocated computing resources, perform submatrix calculations on nodes in parallel, from lower-level nodes to upper-level nodes, taking the branches under the root node of the Jacobian matrix parallel hierarchical elimination tree as the unit.

[0108] This step calculates the submatrix based on the row-compressed storage format and column linked list of the Jacobian matrix, starting from the last leaf node of the hierarchical elimination tree and working upwards layer by layer. For each node, a dense submatrix, sub_jacoby_matrix, composed of the non-zero elements of the corresponding column in the Jacobian column linked list is first calculated. The first column of the submatrix represents the non-zero column elements in the linked list, and the first row represents the corresponding row elements in the row-compressed storage. The row and column numbers of sub_jacoby_matrix are the row numbers of the non-zero column elements.

[0109] The following is the submatrix calculation process for the i-th node, which consists of two parts: the column element calculation part and the row element calculation part.

[0110] The column element calculation process is as follows:

[0111] Save the addresses of the non-zero elements in the first row of the submatrix linked list of the i-th node to the submatrix row number address register row_id_addr, i.e., row_id_addr←sub_matrix_row_addr[i]. Save the number of non-zero elements in the i-th node's submatrix from the column element count register jacoby_col_num to the i-th node's dimension register sub_dimention_i, i.e., sub_dimention_i←jacoby_col_num[i]. Then, save the value in the i-th node's dimension register as the dimension of the submatrix to the submatrix dimension register sub_matrix_dimention[i], i.e., sub_matrix_dimention[i]←sub_dimention_i. The node submatrix is ​​a square matrix with dimension sub_matrix_row.

[0112] Retrieve the address of the first element of the linked list of the i-th node from the Jacobian matrix column list address pointer register head_jacoby_colptr and save it to the column node address register node_col_addr, i.e., node_col_addr ← head_jacoby_colptr[i]. Retrieve the address of the first non-zero element of the first column of the lower triangular matrix L decomposed from the lower triangular matrix L of the i-th child node from the lower triangular matrix address pointer register L_col_ptr and save it to the lower triangular matrix L column address register L_col_addr, i.e., L_col_addr ← L_col_ptr[i]. Save the address of the submatrix of the i-th node to the Jacobian submatrix address register sub_jacoby_matrix_addr, i.e., sub_jacoby_matrix_addr ← sub_matrix_node[i].

[0113] Set the submatrix row number counter cnt_row to traverse from 1 to the submatrix dimension sub_dimention_i, and repeat the following process:

[0114] Set the burst length of the synchronous dynamic random access memory (SDRAM) to burst_length←12, pull the SDRAM read valid signal high to R_SDRAM_sig←1, set the read data counter to a cyclic count of 1, 2, 3, execute the read SDRAM operation from the address of the first element of the current node column stored in the column node address register, save the data to the data bus RW_SDRAM, when the value of the read data counter is 1 and 2, i.e., cnt_t=1 and 2, save the data on the data bus to the sub-matrix data register sub_jacoby_data respectively, i.e. sub_jacoby_data[63:32]←RW_SDRAM, sub_jacoby_data[31:0]←RW_SDRAM.

[0115] The column element row number value at address node_col_addr in the column node address register is saved to the submatrix row number register sub_jacoby_row, i.e., sub_jacoby_row ← row_num[node_col_addr]. Next, the Jacobian data is saved to the submatrix sub_jacoby_matrix.

[0116] Save the write address of the current Jacobi submatrix data to the Jacobi data address register jacoby_data_addr, i.e., jacoby_data_addr←sub_jacoby_matrix_add+(sub_jacoby_row-1)×sub_dimention_i+1. Save the first column of the Jacobi submatrix, sub_jacoby_data, to the submatrix cell pointed to by the address in the Jacobi data address register, jacobby_data_addr, i.e., sub_jacoby_matrix[jacoby_data_addr]←sub_jacoby_data. Record the row number of the Jacobi submatrix data. Save the submatrix row number, sub_jacoby_row, to the submatrix node row number register, sub_matrix_row_id, i.e., sub_matrix_row_id[row_id_addr]←sub_jacoby_row. Set the column element address pointer of the current matrix to the next non-zero element and save it to the column node address register, node_col_addr, i.e., node_col_addr←down_ptr[node_col_addr].

[0117] Next, the data in the first column of the Jacobi submatrix is ​​synchronously written to the first column of the lower triangular matrix L. The row number written to the lower triangular matrix L is stored in the submatrix node row number register sub_matrix_row_id. The address of the submatrix row node number of the i-th node is the value in the submatrix row number address register row_id_addr. The value in the submatrix dimension register (i.e., the dimension of the i-th submatrix) is saved to the dimension register sub_dimention, i.e., sub_dimention←sub_matrix_dimention[i]. The write address of the lower triangular matrix L is located as the value in the lower triangular matrix L column address register L_col_addr. The Jacobi submatrix data sub_jacoby_data is written to the lower triangular matrix L data register L_data, i.e., L_data[L_col_addr]←sub_jacoby_data. The Jacobi submatrix row number sub_jacoby_row is written to the lower triangular matrix L row register L_row, i.e., L_row[L_col_addr]←sub_jacoby_row. Finally, the write address of the lower triangular matrix L is shifted down by one unit, i.e., L_col_addr ← L_col_addr + 1.

[0118] At this point, the column data of the sub_jacoby_matrix of the i-th node has been calculated, and the first column of the sub_jacoby_matrix has been written into the first column of the lower triangular matrix L.

[0119] Finally, update the column address pointer register L_row_ptr of the lower triangular matrix L so that it points to the write address L_col_addr of the next column data, i.e., L_row_ptr[i+1]←L_col_addr.

[0120] The row element calculation process is as follows:

[0121] Retrieve the address of the first element of the i-th row from the row address pointer register U_row_ptr of the upper triangular matrix U, and save it to the row address register U_row_addr of the upper triangular matrix U, i.e., U_row_addr←U_row_addr[i]. Set the node data counter cnt_col←0, and save the number of row elements of the i-th node to the row element count register node_row_num, i.e., node_row_num←jacoby_row_ptr[i+1]-jacoby_row_ptr[i]. When the value of the node data counter cnt_col is less than the value in the row element count register, repeat the following process:

[0122] First, save the starting row address of node i to the row node address register node_row_addr, i.e., node_row_addr←jacoby_row_ptr[i]. Set the SDRAM read / write burst length, i.e. burst_length←12. Pull the SDRAM read valid signal high, i.e. R_SDRAM_sig←1. Set the read data counter to 1, 2, 3 for a cyclic count. Perform a read SDRAM operation from the address of the first element of the current node row in the row node address register. Save the data to the data bus RW_SDRAM. When the read data counter value is 1 and 2, i.e., cnt_t=1 and 2, save the data on the data bus to the sub_jacoby_data register, i.e., sub_jacoby_data[63:32]←RW_SDRAM, sub_jacoby_data[31:0]←RW_SDRAM. When the read data counter value is 3, i.e., cnt_t=3, save the data on the data bus to the Jacobian submatrix column label register sub_jacoby_col, i.e., sub_jacoby_col←RW_SDRAM.

[0123] Save the column index value of the target column of the current submatrix to the target column register target_col, i.e., target_col ← sub_matrix_row_id[cnt_col+1]. If the submatrix column index value sub_jacoby_co is the same as the target column index value in the target column register, execute the following process:

[0124] The starting address of the Jacobi submatrix, sub_jacoby_matrix_addr, is added to the offset address of the Jacobi submatrix data to be written, cnt_col+2, and saved to the Jacobi data address register, jacoby_data_addr. That is, jacoby_data_addr ← sub_jacoby_matrix_addr + cnt_col+2. The Jacobi submatrix data, sub_jacoby_data, is written to the submatrix pointed to by the Jacobi data address register, jacoby_data_addr. That is, sub_jacoby_matrix[jacoby_data_addr] ← sub_jacoby_data. Then, the node data counter, cnt_col, is updated ← cnt_col+1.

[0125] Next, the data of the first row of the Jacobi submatrix is ​​synchronously written to the first row of the upper triangular matrix U. The column number of the data to be written to the first row of the upper triangular matrix U is stored in the submatrix row node number register sub_matrix_row_id. The write address of the upper triangular matrix U is located as the value in the row address register U_row_addr of the upper triangular matrix U. The Jacobi submatrix data sub_jacoby_data is written to the data register U_data of the upper triangular matrix U, i.e., _data[U_row_addr]←sub_jacoby_data. The Jacobi submatrix column number sub_jacoby_col is written to the column register U_col of the upper triangular matrix U, i.e., U_col[U_row_addr]←sub_jacoby_col. Finally, the write address U_row_addr of the upper triangular matrix U is shifted down by one unit, i.e., U_row_addr←U_row_addr+1.

[0126] At this point, the data for the sub_jacoby_matrix of the i-th node has been calculated, and the first row of the sub_jacoby_matrix has been written into the first row of the upper triangular matrix U.

[0127] Finally, update the row offset address pointer register U_row_ptr of the upper triangular matrix U so that it points to the next row write address u_row_addr, i.e., U_row_ptr[i+1]←u_row_addr.

[0128] Thus, by following the above column element calculation process and row element calculation process, the sub_jacoby_matrix can be calculated.

[0129] Step 3: Store the Jacobian submatrix obtained by submatrix calculation, and store the LU decomposition of the node-dense submatrix and the contribution submatrix obtained by the LU decomposition of the submatrix.

[0130] This step uses the following methods: Figure 3The node submatrix LU decomposition and contribution matrix linked list structure shown is as follows: Set the node submatrix address register sub_matrix_node[31:0][2(n-1)-1:0] to store the storage address of each node submatrix, where n represents the number of nodes, and sub_matrix_node[i] points to the storage address of the first element of the dense submatrix sub_jacoby_matrix formed by the i-th node. Each child node has a submatrix storing a linked list to store intermediate submatrix decomposition results during the computation process. This submatrix storage linked list includes a dense submatrix register `sub_jacoby_matrix`, an LU decomposition register `sub_matrix_LU`, and a contribution submatrix register `sub_matrix_contribution`. The dense submatrix `sub_jacoby_matrix` contains three auxiliary registers: the first auxiliary register `sub_matrix_row_id` and the second auxiliary register `sub_matrix_col_id` store the row and column indices of the non-zero rows in the current column of the dense submatrix, respectively; the third auxiliary register `sub_matrix_dimension[2(n-1)-1:0]` stores the dimensions of the dense submatrix. The LU decomposition register `sub_matrix_LU` stores the LU decomposition result for each node. The contribution submatrix register `sub_matrix_contribution` stores the contribution matrix of the current node to other nodes in the upper layer. The `sub_matrix_row_addr` register stores the starting address of the row number of the i-th node.

[0131] Step 4: Superimpose the contribution submatrix calculated by the lower-level nodes onto the corresponding nodes in the upper level, and update the data in the Jacobi submatrix synchronously.

[0132] like Figure 4 As shown, this represents the cumulative contribution of the submatrix calculation results to the related nodes at the upper level. For node i, the contribution values ​​of all descendant nodes of node i to node i need to be accumulated into the original Jacobian matrix. The accumulated and updated Jacobian matrix value is stored in the update_jacoby register. When performing matrix decomposition at each node, the latest accumulated value in the update_jacoby register needs to be used for the next matrix decomposition.

[0133] This step involves superimposing the contribution submatrix of the lower-level node i to the corresponding upper-level node, thus updating the Jacobian matrix. The dimension of the contribution submatrix of the lower-level node i to the upper-level node is the dimension of the Jacobian submatrix sub_jacoby_matrix minus 1.

[0134] Retrieve the dimension of the Jacobian submatrix of node i from the submatrix dimension register sub_matrix_dimention and save it to the sub_dimention register, i.e., sub_dimention←sub_matrix_dimention[i]. Calculate the dimension of the contribution submatrix and save it to contri_dimention←sub_dimention-1. Retrieve the storage address of the LU submatrix after submatrix decomposition of the i-th node from the submatrix address pointer register sub_matrix_node and save it to the sub_LU_addr register, i.e., sub_LU_addr←sub_matrix_node[i].

[0135] Set the row number counter `row_i` of the submatrix to iterate from 2 to the contributing submatrix dimension `contri_dimention`, and simultaneously set the column number counter `col_j` of the submatrix to iterate from 2 to the contributing submatrix dimension `contri_dimention`. Repeat the following process:

[0136] First, the storage address of the contribution submatrix is ​​saved to the contribution submatrix address register contri_addr, i.e., contri_addr←(row_i-1)×contri_dimention+col_j. Then, the contribution submatrix data is retrieved from the contribution submatrix address contri_addr of the LU submatrix register sub_matrix_LU and saved to the contribution submatrix data register contri_data, i.e., contri_data←sub_matrix_LU[contri_addr].

[0137] Next, find the corresponding row and column numbers in the Jacobi matrix affected by the contributing submatrix. Retrieve the corresponding contributing submatrix row and column numbers from the sub_matrix_row_id register and save them to the Jacobi row register jacoby_row_i and the Jacobi column register jacoby_col_j, respectively, i.e., jacoby_row_i←sub_matrix_row_id[row_i], jacoby_col_j←sub_matrix_row_id[col_j].

[0138] Then, the values ​​in the contribution submatri data register `contri_data` are superimposed onto the cells pointed to by the values ​​in the Jacobi row register `jacoby_row_i` and the Jacobi column register `jacoby_col_j`. First, the address of the first non-zero element in the row number corresponding to the value in the Jacobi row register `jacoby_row_i` is saved from the Jacobi row address pointer register `jacoby_row_ptr` to the Jacobi row address register `jacoby_row_addr`, i.e., `jacoby_row_addr←jacoby_row_ptr[jacoby_row_i]`. Then, the column number at the row address in the Jacobi row address register `jacoby_row_addr` is saved to the Jacobi column number register `jacoby_col_id`, i.e., `jacoby_col_id←jacob_col[jacoby_row_addr]`.

[0139] Save the number of row elements at the address in the Jacobi row address register jacoby_row_i in the Jacobi matrix to the Jacobi row element count register jacoby_row_num, that is, jacoby_row_num←jacoby_row_ptr[jacoby_row_i+1]-jacoby_row_ptr[jacoby_row_i].

[0140] Set the Jacobian element count counter cnt_col to 0. When the value in the Jacobian column number register jacoby_col_id is not equal to the value in the Jacobian column register jacoby_col_j, and the value in the Jacobian data count counter cnt_col is less than the value in the Jacobian row element count register jacoby_row_num, the following process is executed:

[0141] Update the current Jacobian row address register, i.e., jacoby_row_addr ← jacoby_row_addr + 1. Save the column number of the next Jacobian element in the current row to the Jacobian column number register jacoby_col_id, i.e., jacoby_col_id ← jacoby_col [jacoby_row_addr]. Update the Jacobian element count counter, i.e., cnt_col ← cnt_col + 1. At this point, the position jacoby_row_addr where the contribution submatrix is ​​written to the Jacobian matrix has been found.

[0142] At the address in the Jacobi row address register `jacoby_row_addr`, historical data is retrieved from the Jacobi data register `jacoby_data` and saved to the Jacobi historical data register `old_jacoby_data`, i.e., `old_jacoby_data ← jacoby_data [jacoby_row_addr]`. The value of the contribution submatri `contri_data` is superimposed onto the current Jacobi matrix, and the new value is saved to the new Jacobi data register `new_jacoby_data`, i.e., `new_jacoby_data ← old_jacoby_data + contri_data`. Finally, the value in the new Jacobi data register is saved to the Jacobi data register `jacoby_data`, i.e., `jacoby_data [jacoby_row_addr] ← new_jacoby_data`.

[0143] This completes the process of numerically superimposing and updating the original Jacobian matrix using the contribution submatrix.

[0144] like Figure 5 As shown, when performing local Jacobian matrix LU decomposition at child node k, the first row of the calculated sub_matrix_LU is the k-th row of the upper triangular matrix U, and the first column of sub_matrix_LU is the lower half of the k-th column of the lower triangular matrix L. Once all nodes in the parallel hierarchical elimination tree have completed their parallel upward computation from the end, the LU decomposition of the original Jacobian matrix is ​​also completed synchronously, which can accelerate the efficiency of solving the power flow equation system.

[0145] It is easy to see that this invention, through a hierarchical iterative parallel computing mode of matrix nodes, allocates different amounts of computing resources to each branch and each node. Matrix decomposition of node submatrices is performed in parallel from lower-level nodes to upper-level nodes. Finally, through a submatrix linked list, the contribution submatrices calculated by lower-level nodes are superimposed onto the corresponding upper-level nodes, synchronously updating the Jacobian matrix. This method enables the highest degree of parallel execution when solving sparse power flow equations in large-scale networks, accelerates the computation time of traditional matrix decomposition, reduces the time required to solve equations serially, improves the efficiency of power flow equation matrix decomposition, and enhances the effectiveness of power flow computation.

[0146] The second embodiment of the present invention relates to a hierarchical iterative parallel computing device for power flow sparse equations with multiple front edges, such as... Figure 8 As shown, it includes:

[0147] The node resource allocation calculation module is used to allocate different amounts of computing resources to each branch and each node of the parallel hierarchical elimination tree of the Jacobian matrix according to the structural characteristics of the Jacobian matrix parallel hierarchical elimination tree.

[0148] The node submatrix parallel decomposition module is used to perform submatrix calculations on nodes in parallel from lower-level nodes to upper-level nodes, based on the allocated computing resources and taking the branches under the root node of the Jacobian matrix parallel hierarchical elimination tree as the unit.

[0149] The Jacobi submatrix linked list calculation module is used to store the Jacobi submatrix obtained by submatrix calculation, and to store the LU decomposition of the node dense submatrix and the contribution submatrix obtained by the LU decomposition of the submatrix.

[0150] The overlay calculation module is used to overlay the contribution submatrix calculated by the lower-level nodes onto the corresponding nodes in the upper level, and synchronously update the data in the Jacobi submatrix.

[0151] The node resource allocation calculation module includes a forward search unit and a reverse search unit. The forward search unit searches downward from the root node of the Jacobian matrix parallel hierarchical elimination tree to estimate the number of node submatrix calculation resources allocated to all nodes of the Jacobian matrix parallel hierarchical elimination tree. The reverse search unit searches upward from the last node of the Jacobian matrix parallel hierarchical elimination tree to perform numbering and allocation of node submatrix calculation resources and correct the number of resources.

[0152] The forward search unit, when performing processing, includes:

[0153] If the root node's address pointer is not null, repeat the following process:

[0154] Search each node in the hierarchical elimination tree sequentially, obtain the child node numbers of the root node, and save them to the child node count register;

[0155] Determine if the current root node is a supernode. If the current root node is not a supernode, record the resources required by the current root node and save the value in the child node count register to the node resource allocation register. If the current root node is a supernode, save the starting node address of the supernode from the supernode linked list according to the current root node number to the supernode address register.

[0156] Traverse all supernodes and repeat the following process: retrieve the current supernode number from the supernode number register and save it to the supernode number register; save the value in the supernode number register to the node resource register; retrieve the address of the next supernode from the supernode pointer register and save it to the supernode address register.

[0157] Complete the resource allocation for the current root node, proceed to the next node search, save the currently found root node number to the leaf node number register, save the current root node address to the leaf node address register, and update the value in the root node address register to the address pointer of the next root node.

[0158] The reverse search unit, when performing processing, includes:

[0159] The resource allocation address of the leaf node found in the forward search unit is pointed to the cell address where the new resource is to be inserted. The newly added resource allocation address is connected to the node resource allocation list at the current leaf node number. The resource quantity register required by the node at the current address is updated.

[0160] Determine the number of child nodes of the parent node of the current node, save the address of the parent node of the current leaf node from the parent node register to the parent node address register, and retrieve the number of child nodes of the parent node from the child node count register and save it to the parent node child node count register.

[0161] While the value in the parent node's address register is not empty, the following process is executed repeatedly:

[0162] Set the node resource allocation address pointer register at the current leaf node address to the cell address where the new resource is to be inserted, and save the offset address of the current leaf node linked list to the starting address register of the resource required by the current node;

[0163] Find the resource ID of the child node of the current leaf node, retrieve the number of child nodes of the leaf node, and save it to the leaf node's child node count register. Retrieve the starting address of the child node from the child node linked list address pointer linked list register and save it to the leaf node's child node address register. Traverse all child nodes of the leaf node and repeat the following first sub-process:

[0164] The first sub-process includes:

[0165] Retrieve the child node number and save it to the child node number register of the leaf node. Then, find the resource allocation number of each child node in turn. Save the starting address of the current child node's resource allocation to the child node resource address register of the leaf node, and save the resource quantity of the child node to the child node resource quantity register of the leaf node. Iterate through each resource of the child node and repeat the following second sub-process:

[0166] The second sub-process includes:

[0167] Write the value in the child node number register of the leaf node to the resource number register at the parent node address; save the starting address of the resource required by the current node to the address pointer register of the previous resource; update the starting address of the resource required by the current node to the cell address of the new resource to be inserted; increment the address pointed to by the address pointer register of the next resource of the current node by 1;

[0168] Find the address of the next child node of the leaf node and save it to the child node address register of the leaf node, thus completing the resource numbering of the child nodes of all leaf nodes;

[0169] Update the search order, continue searching to the parent node of the current leaf node, save the parent node number of the current leaf node from the parent node number register to the leaf node number register, and save the parent node address of the current node to the parent node address register.

[0170] The parallel decomposition module for the node submatrix includes a column element calculation unit, which, during processing, includes:

[0171] Save the address of the non-zero element in the first row of the submatrix linked list of the i-th node to the submatrix row number address register. Save the number of non-zero elements in the submatrix of the i-th node from the column element count register to the dimension register of the i-th node. Then save the value in the dimension register of the i-th node as the dimension of the submatrix to the submatrix dimension register.

[0172] Retrieve the first address of the i-th node's column list from the Jacobian matrix column list address pointer register and save it to the column node address register; retrieve the address of the first non-zero element of the first column of the lower triangular matrix L decomposed from the i-th child node from the lower triangular matrix address pointer register and save it to the lower triangular matrix L column address register; save the address of the submatrix of the i-th node to the Jacobian submatrix address register;

[0173] Iterate through the dimensions of the submatrix, repeating the following process:

[0174] Set the memory read / write burst length, pull the memory read valid signal high, set the read data counter to a cyclic count of 1, 2, 3, perform a memory read operation from the address of the first element of the current node column stored in the column node address register, save the data to the data bus, and save the data on the data bus to the sub-matrix data register when the value of the read data counter is 1 and 2 respectively.

[0175] Save the column element row number value at the address in the column node address register to the submatrix row number register;

[0176] Save the write address of the current Jacobi submatrix data to the Jacobi data address register; save the first column data of the Jacobi submatrix to the submatrix cell pointed to by the address in the Jacobi data address register, record the row number of the Jacobi submatrix data, save the submatrix row number to the submatrix node row number register, and point the column element address pointer of the current matrix to the next non-zero element and save it to the column node address register;

[0177] The row numbers of the lower triangular matrix L are stored in the submatrix node row number register. The address of the submatrix row node number of the i-th node is the value in the submatrix row number address register. The value in the submatrix dimension register is saved to the dimension register. The write address of the lower triangular matrix L is located as the value in the lower triangular matrix L column address register. The Jacobian submatrix data is written to the lower triangular matrix L data register. The Jacobian submatrix row numbers are written to the row register of the lower triangular matrix L. The write address of the lower triangular matrix L is shifted down one unit.

[0178] After completing the traversal, the column data of the Jacobi submatrix of the i-th node is obtained, and the first column of the Jacobi submatrix is ​​written into the first column of the lower triangular matrix L;

[0179] Update the column address pointer register of the lower triangular matrix L so that it points to the write address of the next column data.

[0180] The parallel decomposition module for the node submatrix includes a row element calculation unit, which, when performing processing, includes:

[0181] Retrieve the address of the first element of the i-th row from the row address pointer register of the upper triangular matrix U and store it in the row address register of the upper triangular matrix U; initialize the node data counter and store the number of row elements of the i-th node in the row element count register. When the value of the node data counter is less than the value in the row element count register, repeat the following process:

[0182] Save the starting row address of the i-th node to the row node address register, set the memory read / write burst length, and pull the memory read valid signal high; set the read data counter to count in a loop of 1, 2, and 3, perform a memory read operation from the address of the first element of the current node's row stored in the row node address register, save the data to the data bus, save the data on the data bus to the submatrix data register when the read data counter value is 1 and 2, and save the data on the data bus to the Jacobi submatrix column label register when the read data counter value is 3;

[0183] Save the column index value of the target column of the current submatrix to the target column register. If the submatrix column index value is the same as the value in the target column register, execute the following process:

[0184] Save the starting address of the Jacobi submatrix plus the offset address of the Jacobi submatrix data to be written to the Jacobi data address register, and write the Jacobi submatrix data to the submatrix pointed to by the Jacobi data address register;

[0185] The column number of the first row of data written to the upper triangular matrix U is stored in the submatrix row node number register. The write address of the upper triangular matrix U is located as the value in the row address register of the upper triangular matrix U. The Jacobi submatrix data is written to the data register of the upper triangular matrix U. The Jacobi submatrix column number is written to the column register of the upper triangular matrix U. The write address of the upper triangular matrix U is shifted down one unit.

[0186] After completing the above process, the row data of the Jacobi submatrix of the i-th node is obtained, and the first row of the Jacobi submatrix is ​​written into the first row of the upper triangular matrix U.

[0187] Update the row offset address pointer register of the upper triangular matrix U so that it points to the next row write address.

[0188] The Jacobi submatrix linked list calculation module stores the Jacobi submatrix calculated from the submatrix. When storing the LU decomposition of the node dense submatrix and the contribution submatrix obtained from the LU decomposition of the submatrix, the sub_matrix_node[31:0][2(n-1)-1:0] register is set to store the storage address of each node submatrix, where n represents the number of nodes and sub_matrix_node[i] represents the storage address of the first element of the dense submatrix formed by the i-th node. Each child node sets up a submatrix storage linked list to store the intermediate submatrix decomposition results during the calculation process. The submatrix storage linked list includes a dense submatrix register, an LU decomposition register, and a contribution submatrix register. The dense submatrix contains three auxiliary registers. The first and second auxiliary registers store the row index and column index values ​​of the non-zero rows in the current column of the dense submatrix, respectively. The third auxiliary register stores the dimension of the dense submatrix. The LU decomposition register stores the result of LU decomposition of each node, and the contribution submatrix register stores the contribution matrix of the current node to other nodes in the upper layer.

[0189] The superposition calculation module superimposes the contribution submatrix calculated by the lower-level nodes onto the corresponding nodes in the upper level. When synchronously updating the data in the Jacobian submatrix, the specific steps include:

[0190] Iterate through all rows and columns of the contribution submatrix, repeating the following process:

[0191] The storage address of the contribution submatrix is ​​saved to the contribution submatrix address register, and then the contribution submatrix data is retrieved from the contribution submatrix address in the LU submatrix register and saved to the contribution submatrix data register;

[0192] Retrieve the corresponding contribution submatrix row number and column number from the Jacobi submatrix row number register and save them to the Jacobi row register and Jacobi column register, respectively;

[0193] The values ​​in the contribution submatrix data register are superimposed onto the cells pointed to by the Jacobi row register and the Jacobi column register; the address of the first non-zero element of the row number corresponding to the value in the Jacobi row register is saved from the Jacobi row address pointer register to the Jacobi row address register, and the column number at the address in the Jacobi row address register is saved to the Jacobi column number register.

[0194] Save the number of row elements at the address in the Jacobian row address register to the Jacobian row element count register;

[0195] Initialize the Jacobian element count counter. When the value in the Jacobian column number register is not equal to the value in the Jacobian column register, and the value of the Jacobian data element count counter is less than the value in the Jacobian row element count register, execute the following procedure:

[0196] Update the current Jacobian row address register, save the column number of the next Jacobian element in the current row to the Jacobian column number register, and update the Jacobian element count counter.

[0197] At the address in the Jacobi row address register, retrieve historical data from the Jacobi data register and save it to the Jacobi historical data register. Add the value of the contribution submatrix to the current Jacobi matrix and save the new value to the new Jacobi data register. Save the value in the new Jacobi data register to the Jacobi data register.

[0198] The third embodiment of the present invention relates to a power flow parallel computing system based on FPGA, such as... Figure 9 As shown, a hierarchical iterative parallel computing device for power flow sparse equations with multiple frontiers, including the second embodiment, is provided.

[0199] The fourth embodiment of the present invention relates to a computer-readable storage medium having a computer program stored thereon, wherein the computer program, when executed by a processor, implements the steps of the hierarchical iterative parallel computation method for the sparse power flow equations of the multi-front edge of the first embodiment.

[0200] Those skilled in the art will understand that embodiments of this application can be provided as methods, systems, or computer program products. Therefore, this application can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, this application can take the form of a computer program product implemented on one or more computer-usable storage media (including, but not limited to, disk storage and optical storage) containing computer-usable program code.

[0201] This application is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of this application. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, generate instructions for implementing the flowchart... Figure 1 One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0202] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to operate in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction methods implemented in a process. Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.

[0203] These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0204] The above description is merely a specific embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the technical scope disclosed in the present invention should be included within the scope of protection of the present invention. Therefore, the scope of protection of the present invention should be determined by the scope of the claims.

Claims

1. A hierarchical iterative parallel computation method for power flow sparse equations with multiple front edges, characterized in that, Includes the following steps: Based on the structural characteristics of the parallel hierarchical elimination tree of the Jacobian matrix, different amounts of computing resources are allocated to each branch and each node of the parallel hierarchical elimination tree of the Jacobian matrix. This includes a forward search processing stage and a backward search processing stage. The forward search processing stage searches downward from the root node of the parallel hierarchical elimination tree of the Jacobian matrix to estimate the number of node submatrix computing resources allocated to all nodes of the parallel hierarchical elimination tree of the Jacobian matrix. The backward search processing stage searches upward from the last node of the parallel hierarchical elimination tree of the Jacobian matrix to perform node submatrix computing resource numbering and resource quantity correction. Based on the allocated computing resources, submatrix calculations are performed on nodes in parallel from lower-level nodes to upper-level nodes, taking the branches under the root node of the Jacobian matrix parallel hierarchical elimination tree as the unit. Store the Jacobian submatrix obtained by submatrix calculation, and store the LU decomposition of the node dense submatrix and the contribution submatrix obtained by submatrix LU decomposition. The contribution submatrix calculated by the lower-level nodes is superimposed on the corresponding nodes in the upper level, and the data in the Jacobi submatrix is ​​updated synchronously.

2. The hierarchical iterative parallel computation method for power flow sparse equations with multiple front edges according to claim 1, characterized in that, The forward search processing stage specifically includes: If the root node's address pointer is not null, repeat the following process: Search each node in the hierarchical elimination tree sequentially, obtain the child node numbers of the root node, and save them to the child node count register; Determine if the current root node is a supernode. If the current root node is not a supernode, record the resources required by the current root node and save the value in the child node count register to the node resource allocation register. If the current root node is a supernode, save the starting node address of the supernode from the supernode linked list according to the current root node number to the supernode address register. Traverse all supernodes and repeat the following process: retrieve the current supernode number from the supernode number register and save it to the supernode number register; save the value in the supernode number register to the node resource register; retrieve the address of the next supernode from the supernode pointer register and save it to the supernode address register. Complete the resource allocation for the current root node, proceed to the next node search, save the currently found root node number to the leaf node number register, save the current root node address to the leaf node address register, and update the value in the root node address register to the address pointer of the next root node.

3. The hierarchical iterative parallel computation method for power flow sparse equations with multiple front edges according to claim 1, characterized in that, The reverse search processing stage specifically includes: In the forward search processing stage, the resource allocation address of the leaf node found is pointed to the cell address where the new resource is to be inserted. The newly added resource allocation address is connected to the node resource allocation list at the current leaf node number. The resource quantity register required by the node at the current address is updated. Determine the number of child nodes of the parent node of the current node, save the address of the parent node of the current leaf node from the parent node register to the parent node address register, and retrieve the number of child nodes of the parent node from the child node count register and save it to the parent node child node count register. While the value in the parent node's address register is not empty, the following process is executed repeatedly: Set the node resource allocation address pointer register at the current leaf node address to the cell address where the new resource is to be inserted, and save the offset address of the current leaf node linked list to the starting address register of the resource required by the current node; Find the resource ID of the child node of the current leaf node, retrieve the number of child nodes of the leaf node, and save it to the leaf node's child node count register. Retrieve the starting address of the child node from the child node linked list address pointer linked list register and save it to the leaf node's child node address register. Traverse all child nodes of the leaf node and repeat the following first sub-process: The first sub-process includes: Retrieve the child node number and save it to the child node number register of the leaf node. Then, find the resource allocation number of each child node in turn. Save the starting address of the current child node's resource allocation to the child node resource address register of the leaf node, and save the resource quantity of the child node to the child node resource quantity register of the leaf node. Iterate through each resource of the child node and repeat the following second sub-process: The second sub-process includes: Write the value in the child node number register of the leaf node to the resource number register at the parent node address; save the starting address of the resource required by the current node to the address pointer register of the previous resource; update the starting address of the resource required by the current node to the cell address of the new resource to be inserted; increment the address pointed to by the address pointer register of the next resource of the current node by 1; Find the address of the next child node of the leaf node and save it to the child node address register of the leaf node, thus completing the resource numbering of the child nodes of all leaf nodes; Update the search order, continue searching to the parent node of the current leaf node, save the parent node number of the current leaf node from the parent node number register to the leaf node number register, and save the parent node address of the current node to the parent node address register.

4. The hierarchical iterative parallel computation method for power flow sparse equations with multiple front edges according to claim 1, characterized in that, The submatrix calculation of the nodes includes column element calculation, which specifically includes: Save the address of the non-zero element in the first row of the submatrix linked list of the i-th node to the submatrix row number address register. Save the number of non-zero elements in the submatrix of the i-th node from the column element count register to the dimension register of the i-th node. Then save the value in the dimension register of the i-th node as the dimension of the submatrix to the submatrix dimension register. Retrieve the first address of the i-th node's column list from the Jacobian matrix column list address pointer register and save it to the column node address register; retrieve the address of the first non-zero element of the first column of the lower triangular matrix L decomposed from the i-th child node from the lower triangular matrix address pointer register and save it to the lower triangular matrix L column address register; save the address of the submatrix of the i-th node to the Jacobian submatrix address register; Iterate through the dimensions of the submatrix, repeating the following process: Set the memory read / write burst length, pull the memory read valid signal high, set the read data counter to a cyclic count of 1, 2, 3, perform a memory read operation from the address of the first element of the current node column stored in the column node address register, save the data to the data bus, and save the data on the data bus to the sub-matrix data register when the value of the read data counter is 1 and 2 respectively. Save the column element row number value at the address in the column node address register to the submatrix row number register; Save the write address of the current Jacobi submatrix data to the Jacobi data address register; save the first column data of the Jacobi submatrix to the submatrix cell pointed to by the address in the Jacobi data address register, record the row number of the Jacobi submatrix data, save the submatrix row number to the submatrix node row number register, and point the column element address pointer of the current matrix to the next non-zero element and save it to the column node address register; The row numbers of the lower triangular matrix L are stored in the submatrix node row number register. The address of the submatrix row node number of the i-th node is the value in the submatrix row number address register. The value in the submatrix dimension register is saved to the dimension register. The write address of the lower triangular matrix L is located as the value in the lower triangular matrix L column address register. The Jacobian submatrix data is written to the lower triangular matrix L data register. The Jacobian submatrix row numbers are written to the row register of the lower triangular matrix L. The write address of the lower triangular matrix L is shifted down one unit. After completing the traversal, the column data of the Jacobi submatrix of the i-th node is obtained, and the first column of the Jacobi submatrix is ​​written into the first column of the lower triangular matrix L; Update the column address pointer register of the lower triangular matrix L so that it points to the write address of the next column data.

5. The hierarchical iterative parallel computation method for power flow sparse equations with multiple front edges according to claim 1, characterized in that, The submatrix calculation of the nodes includes row element calculation, which specifically includes: Retrieve the address of the first element of the i-th row from the row address pointer register of the upper triangular matrix U and store it in the row address register of the upper triangular matrix U; initialize the node data counter and store the number of row elements of the i-th node in the row element count register. When the value of the node data counter is less than the value in the row element count register, repeat the following process: Save the starting row address of the i-th node to the row node address register, set the memory read / write burst length, and pull the memory read valid signal high; set the read data counter to 1, 2, 3 for cyclic counting, perform a memory read operation from the address of the first element of the current node's row stored in the row node address register, save the data to the data bus, and save the data on the data bus to the submatrix data register when the read data counter value is 1 and 2 respectively, and save the data on the data bus to the Jacobian submatrix column label register when the read data counter value is 3; save the column label value of the current submatrix target column to the target column register, and if the submatrix column label value is the same as the value in the target column register, execute the following process: Save the starting address of the Jacobi submatrix plus the offset address of the Jacobi submatrix data to be written to the Jacobi data address register, and write the Jacobi submatrix data to the submatrix pointed to by the Jacobi data address register; The column number of the first row of data written to the upper triangular matrix U is stored in the submatrix row node number register. The write address of the upper triangular matrix U is located as the value in the row address register of the upper triangular matrix U. The Jacobi submatrix data is written to the data register of the upper triangular matrix U. The Jacobi submatrix column number is written to the column register of the upper triangular matrix U. The write address of the upper triangular matrix U is shifted down one unit. After completing the above process, the row data of the Jacobi submatrix of the i-th node is obtained, and the first row of the Jacobi submatrix is ​​written into the first row of the upper triangular matrix U. Update the row offset address pointer register of the upper triangular matrix U so that it points to the next row write address.

6. The hierarchical iterative parallel computation method for power flow sparse equations with multiple front edges according to claim 1, characterized in that, The process of storing the Jacobian submatrix obtained from the submatrix calculation, and storing the LU decomposition of the node dense submatrix and the contribution submatrix obtained from the LU decomposition of the submatrix, specifically involves: setting a node submatrix address register to store the storage address of each node submatrix; setting a submatrix storage linked list for each child node to store the intermediate submatrix decomposition results during the calculation process, wherein the submatrix storage linked list includes a dense submatrix register, an LU decomposition register, and a contribution submatrix register; wherein, the dense submatrix contains three auxiliary registers, the first and second auxiliary registers respectively store the row index and column index values ​​of the non-zero rows in the current column of the dense submatrix, and the third auxiliary register stores the dimension of the dense submatrix; the LU decomposition register stores the result of LU decomposition of each node, and the contribution submatrix register stores the contribution matrix of the current node to other nodes in the upper layer.

7. The hierarchical iterative parallel computation method for power flow sparse equations with multiple front edges according to claim 1, characterized in that, The step of superimposing the contribution submatrix calculated by the lower-level nodes onto the corresponding nodes in the upper level, and synchronously updating the data in the Jacobi submatrix, specifically includes: Iterate through all rows and columns of the contribution submatrix, repeating the following process: The storage address of the contribution submatrix is ​​saved to the contribution submatrix address register, and then the contribution submatrix data is retrieved from the contribution submatrix address in the LU submatrix register and saved to the contribution submatrix data register; Retrieve the corresponding contribution submatrix row number and column number from the Jacobi submatrix row number register and save them to the Jacobi row register and Jacobi column register, respectively; The values ​​in the contribution submatrix data register are superimposed onto the cells pointed to by the Jacobi row register and the Jacobi column register; the address of the first non-zero element of the row number corresponding to the value in the Jacobi row register is saved from the Jacobi row address pointer register to the Jacobi row address register, and the column number at the address in the Jacobi row address register is saved to the Jacobi column number register. Save the number of row elements at the address in the Jacobian row address register to the Jacobian row element count register; Initialize the Jacobian element count counter. When the value in the Jacobian column number register is not equal to the value in the Jacobian column register, and the value of the Jacobian data element count counter is less than the value in the Jacobian row element count register, execute the following procedure: Update the current Jacobian row address register, save the column number of the next Jacobian element in the current row to the Jacobian column number register, and update the Jacobian element count counter. At the address in the Jacobi row address register, retrieve historical data from the Jacobi data register and save it to the Jacobi historical data register. Add the value of the contribution submatrix to the current Jacobi matrix and save the new value to the new Jacobi data register. Save the value in the new Jacobi data register to the Jacobi data register.

8. A hierarchical iterative parallel computing device for power flow sparse equations with multiple front edges, characterized in that, include: The node resource allocation calculation module is used to allocate different amounts of computing resources to each branch and each node of the Jacobian matrix parallel hierarchical elimination tree according to the structural characteristics of the tree. The module includes a forward search unit and a reverse search unit. The forward search unit searches downwards from the root node of the Jacobian matrix parallel hierarchical elimination tree to estimate the number of node submatrix computing resources allocated to all nodes. The reverse search unit searches upwards from the last node of the Jacobian matrix parallel hierarchical elimination tree to assign node submatrix computing resources and correct the resource quantity. The node submatrix parallel decomposition module is used to perform submatrix calculations on nodes in parallel from lower-level nodes to upper-level nodes, based on the allocated computing resources and taking the branches under the root node of the Jacobian matrix parallel hierarchical elimination tree as the unit. The Jacobi submatrix linked list calculation module is used to store the Jacobi submatrix obtained by submatrix calculation, and to store the LU decomposition of the node dense submatrix and the contribution submatrix obtained by the LU decomposition of the submatrix. The overlay calculation module is used to overlay the contribution submatrix calculated by the lower-level nodes onto the corresponding nodes in the upper level, and synchronously update the data in the Jacobi submatrix.

9. A power flow parallel computing system based on FPGA, characterized in that, Includes the hierarchical iterative parallel computing device for power flow sparse equations with multiple front surfaces as described in claim 8.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by the processor, it implements the steps of the hierarchical iterative parallel computation method for the power flow sparse equation with multiple front surfaces as described in any one of claims 1-7.

Images