Abstract:
Systems and methods related to fast simulation of power delivery networks are described. A method is provided for simulating the time-domain responses of a plurality of points of a multi-layer power delivery network, comprising selecting a model of the power delivery network of a circuit, parsing the characteristic data describing the power delivery network, forming a circuit matrix relating to said circuit characteristic data, creating a preconditioner matrix with a specialized structure that allows solution by a Fast Transform solver, simulating the circuit using said circuit and preconditioner matrices by a computer, including a non-transitory computer readable storage medium and at least one processor, but preferably multiple processors, and reporting the responses at selected nodes and branches of the power delivery network.

Description:
CLAIM OF PRIORITY 
     This application claims the benefit of priority to U.S. Provisional patent application titled “FAST TRANSFORM-BASED PRECONDITIONERS FOR LARGE-SCALE POWER GRID ANALYSIS ON MASSIVELY PARALLEL ARCHITECTURES”, Application No. 61/715,499, filed Oct. 18, 2012, and incorporated herein by reference. 
    
    
     FIELD OF THE INVENTION 
     The invention relates to the field of circuit design and simulation, and specifically to fast simulation of large-scale power delivery networks utilizing preconditioners and parallel computing schemes. 
     BACKGROUND 
     The relentless push for high-performance and low-power integrated circuits has been met by aggressive technology scaling, which enabled the integration of a vast number of devices on the same die but brought new problems and challenges to the surface. The on-chip power delivery network (power grid) constitutes a vital subsystem of modern nanometer-scale ICs, since it affects in a critical way the performance and correct operation of the devices. In order to determine the quality of the supply voltage delivered to the devices, the designer has to perform static and dynamic simulation of the electrical circuit modeling the power grid. This has become a very challenging problem for contemporary ICs, since power grids encountered in these circuits are extremely large (comprising several thousands or millions of nodes) and very difficult to simulate efficiently (especially over multiple time-steps). 
     Static (DC) or transient simulation refers to the process of computing the response of an electrical circuit to a constant or time-varying stimulus. Since a power delivery network can be generally modeled as a linear RLC circuit, the process of DC or transient simulation of large-scale power grids amounts to solving very large (and sparse) linear systems of equations. Direct methods (based on matrix factorization) have been widely used in the past for solving the resulting linear systems, mainly because of their robustness in most types of problems. They also have the property of reusability of factorization results in transient simulation with a fixed time-step. Unfortunately, these methods do not scale well with the dimension of the linear system, and become prohibitively expensive for circuits beyond a few thousand elements, in both execution time and memory requirements. In addition, a fixed time-step is almost never used in practice because it becomes very inefficient to constantly simulate during long intervals of low activity. All practical implementations of integration techniques for ordinary differential equations (ODEs) employ a variable or adaptive time-step mechanism. In those cases, the reusability of matrix factorization in direct methods ceases to exist. 
     Iterative methods involve only inner products and matrix-vector products, and constitute a better alternative for large sparse linear systems in many respects, being more computationally- and memory-efficient. This holds even more so for modern non-stationary iterative methods which fall under the broad class of ‘Krylov-subspace’ methods. See e.g. Y. Saad, “Iterative Methods for Sparse Linear Systems”, Chapter 6, which is incorporated herein by reference in its entirety. Iterative methods possess themselves a kind of reusability property for transient simulation, in that the solution at the last time-step provides an excellent initial guess for the next time-step, thus making a properly implemented iterative method converge in a fairly small number of iterations. In fact, this property also holds in the case of a variable time-step, since the quality of the last solution as initial guess for the next solution is not affected. The above features make iterative methods much more suitable for DC and variable time-step transient analysis of large-scale linear circuits such as power distribution networks. 
     The main problem of iterative methods is their unpredictable rate of convergence which depends greatly on the properties (specifically the condition number) of the circuit matrix. A preconditioning mechanism, which transforms the linear system into one with more favorable properties, is essential to guarantee fast and robust convergence. However, the ideal preconditioner (one that approximates the circuit matrix well and is inexpensive to construct and apply) differs according to each particular problem and each different type of circuit matrix. That is why iterative methods have not reached the maturity of direct methods and have not yet gained widespread acceptance in linear circuit simulation. Although general-purpose preconditioners (such as incomplete factorizations or sparse approximate inverses) have been developed, they are not tuned to any particular simulation problems and cannot improve convergence by as much as specially-tailored preconditioners. 
     Another aspect of circuit simulation that has become very important recently is to uncover hidden opportunities for parallelism in its intermediate steps. This is essential for harnessing the potential of contemporary parallel architectures, such as multi-core processors and graphics processing units (GPUs). GPUs, in particular, are massively parallel architectures whose computational power is about 1580 GFlops/s (in 2012), greater by an order of magnitude than that of multi-core processors, and as a result they appear as a platform of choice for the efficient execution of computationally-intensive tasks. However, there has been little systematic research for the development of parallel simulation algorithms, and more specifically algorithms for power grid analysis that can be mapped onto massively parallel architectures. This can be attributed in part to the difficulty in parallelization of direct linear solution methods that have been mostly employed thus far. 
     On the contrary, Krylov-subspace iterative methods offer ample possibilities for parallelism that have been explored sufficiently well. However, the construction and application of the preconditioner is a very delicate part of parallelizing an iterative method because it is completely application-dependent (and traditional general-purpose preconditioners have very little room for parallelism). 
     The growing need to simulate large power grids with small memory footprint and efficient parallel execution has led many researchers to deviate from the standard practice of direct factorization methods and present more suitable iterative methods. This has been studied in the past in several paper, including T.-H. Chen and C. C.-P. Chen, “Efficient Large-Scale Power Grid Analysis Based on Preconditioned Krylov-Subspace Iterative Methods”,  ACM/IEEE Design Automation Conf.,  2001; and J. Shi, Y. Cai, S. X.-D. Tan, J. Fan, and X. Hong, “Pattern-Based Iterative Method for Extreme Large Power/Ground Analysis”, in  IEEE Trans. Computer - Aided Design,  26(4):680-692, 2007, each incorporated herein by reference in their entirety, that have proposed iterative solvers for efficient simulation of power delivery networks. Power grid analysis was first formulated as a symmetric positive definite system to be solved by PCG in Chen et al. (cited above), but the preconditioner used was a general-purpose (and inefficient for specialized applications) known as incomplete Cholesky. 
     A different pattern-based preconditioner was proposed in Shi et al. (cited above), but it is very simple and heuristic and does not appear to reduce the number of iterations significantly. The idea of multi-grid techniques for solving partial differential equations has been proposed for power grid analysis in the past in several papers, including J. Kozhaya, S. Nassif, and F. Najm, “A Multigrid-Like Technique for Power Grid Analysis”,  IEEE Trans. Computer - Aided Design,  21(10):1148-1160, 2002; and C. Zhuo, J. Hu, M. Zhao, and K. Chen, “Power Grid Analysis and Optimization Using Algebraic Multigrid”, in  IEEE Trans. Computer - Aided Design,  27(4):738-751, 2008, each incorporated herein by reference in their entirety. 
     More recently, parallel computing architectures have been utilized to accelerate power grid analysis in several papers, including K. Sun, Q. Zhou, K. Mohanram, and D. C. Sorensen, “Parallel Domain Decomposition for Simulation of Large-Scale Power Grids”,  ACM/IEEE Design Automation Conf.,  2007; J. Shi, Y. Cai, W. Hou, L. Ma, S. X.-D. Tan, P.-H. Ho, and X. Wang, “GPU friendly Fast Poisson Solver for Structured Power Grid Network Analysis”,  ACM/IEEE Design Automation Conf.,  2009; and Z. Feng and Z. Zeng, “Parallel Multigrid Preconditioning on Graphics Processing Units (GPUs) for Robust Power Grid Analysis”,  ACM/IEEE Design Automation Conf.,  2010, each incorporated herein by reference in their entirety. 
     Authors in Feng et al. (cited above) propose multi-grid as a solution method for power grid analysis and they use multi-core and massively parallel single-instruction multiple-thread (SIMT) platforms to tackle power grid analysis, while authors in Shi et al. (cited above) formulate the traditional linear system as a special two-dimension Poisson equation and solve it using analytical expressions based on the FFT algorithm, with GPUs being used to further speed up the algorithm. However, both approaches only solve very regular grid structures with specialized techniques, which can limit their effectiveness for irregular power delivery networks that are found in late design stages. 
     Preconditioning has been studied as a method for efficiently tackling the electrical and thermal analysis of large-scale and irregular power grid designs in several papers in the past, including and Z. Feng, Z. Zeng, and P. Li, “Parallel On-Chip Power Distribution Network Analysis on Multi-Core-Multi-GPU Platforms”,  IEEE Trans. VLSI Syst.,  19(10):1823-1836, 2011; J. Yang, Y. Cai, Q. Zhou, and J. Shi, “Fast Poisson Solver Preconditioned Method for Robust Power Grid Analysis”,  IEEE/ACM Int. Conf. on Computer - Aided Design,  2011; and H. Qian and S. Sapatnekar, “Fast Poisson Solvers for Thermal Analysis”,  IEEE/ACM Int. Conf. Computer - Aided Design,  2010, each incorporated herein by reference in their entirety. In Feng et al. (cited above), the preconditioning has been carried out by multigrid techniques. However, when used as preconditioner for iterative methods, multigrid is not very efficient because it is an iterative method by itself, and also solves a system approximately which can hinder the convergence of PCG. Moreover, some operations of multigrid are not always well-defined (e.g. mapping by interpolation from coarser to finer grids and vice versa, and correction of solutions), and the construction of approximate matrices for all coarser grids is an expensive setup phase which has to be repeated every time the system is reconstructed in each time-step change during transient analysis. 
     SUMMARY 
     Embodiments of the present invention are related to fast simulation of large-scale power delivery networks utilizing Fast Transform-based preconditioners. 
     In accordance with an embodiment, a method is provided for fast simulation of large-scale power delivery networks, comprising selecting a model of a multi-layer power delivery network of a circuit, parsing the characteristic data describing the power delivery network, forming a circuit matrix relating to said circuit characteristic data, creating a preconditioner matrix with a specialized structure that allows solution by a Fast Transform solver, simulating the circuit using said circuit and preconditioner matrices by a computer, including a non-transitory computer readable storage medium and processor, and reporting the voltage response at each of a plurality of nodes of the power delivery network. 
     In accordance with another preferred embodiment, the input netlist that describes the power delivery network contains geometry information for each node of the network. 
     In accordance with another preferred embodiment, the preconditioner matrix that is created is based on a regular power delivery network, which is obtained after a regularization step of the initial power delivery network, and has a specialized structure that allows for solution by a Fast Transform solver. 
     In accordance with another preferred embodiment, the methods described in the present invention can be executed on parallel processing architectures (such as multi-core processors, graphic processing units—GPUs—and networked computer clusters). 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       Embodiments of the invention will now be described, by way of example only, with reference to the accompanying drawings in which: 
         FIG. 1  illustrates the geometry structure of a 3D power grid with 3 layers. Vias provide connections between adjacent metal layers. 
         FIG. 2  illustrates the regular grid obtained after the 2D regularization process. 
         FIG. 3  illustrates the format of the netlist that is provided as input to the methods of the present invention. 
         FIG. 4  illustrates the regular grid obtained after the 3D regularization process. 
         FIG. 5  presents the flow of a preferred method for 2D network simulation according to the invention. 
         FIG. 6  presents the flow of a preferred method for 3D network simulation according to the invention. 
         FIG. 7  presents the flow of a preferred method for solving the preconditioner that corresponds to the 2D regular grid. 
         FIG. 8  presents the flow of a preferred method for solving the preconditioner that corresponds to the 3D regular grid. 
         FIG. 9  presents the flow of a preferred method for 2D grid regularization according to the invention. 
         FIG. 10  presents the flow of a preferred method for 3D grid regularization according to the invention. 
         FIG. 11  illustrates the preferred structure of a preconditioner matrix for 2D networks according to the invention. 
         FIG. 12  illustrates the preferred structure of a preconditioner matrix for 3D networks according to the invention. 
     
    
    
     DETAILED DESCRIPTION 
     The following description is of the best modes presently contemplated for practicing various embodiments of the present invention. The description is not to be taken in a limiting sense but is made merely for the purpose of describing the general principles of the invention. The scope of the invention should be ascertained with reference to the claims. In the description of the invention that follows, like numerals or reference designators will be used to refer to like parts or elements throughout. 
     It would be apparent to one of skill in the art that the present invention, as described below, may be implemented in many different embodiments of hardware, software, firmware, and/or the entities illustrated in the figures. Any actual software, firmware and/or hardware described herein is not limiting of the present invention. Thus, the operation and behavior of the present invention will be described with the understanding that modifications and variations of the embodiments are possible, given the level of detail presented herein. 
     This invention relates to a method and system for simulating large-scale power delivery networks that overcomes limitations in the prior art and offers significant performance improvements. 
     Our approach for preconditioning, based on the application of a Fast Transform, involves a much more straightforward and inexpensive implementation and reconstruction phase for transient simulation over prior art methods, while it also provides analytical solution of the preconditioned system (which is actually a fast direct method). 
     The approach in Yang et al. (cited above) uses a Fast Poisson-based preconditioner to accelerate the convergence rate of Conjugate Gradient. However, the Yang et al. technique is based on the presumed existence of special areas in the grid with zero voltage drop as boundary condition, in order to formulate so-called “Poisson blocks” with Toeplitz matrix structure. As will be demonstrated below, our invention does not necessitate such an assumption. 
     In the same context, research paper X. Zhao, J. Wang, Z. Feng, and S. Hu, “Power Grid Analysis with Hierarchical Support Graphs”,  IEEE/ACM Int. Conf. on Computer - Aided Design,  2011, incorporated herein by reference in its entirety presents a support graph-based preconditioner that can provide a significant acceleration to the convergence rate of an iterative method. However, applying this preconditioner requires the solution of a triangular system which can hinder preconditioner&#39;s applicability on parallel architectures due to the limited parallelism of triangular solution algorithms. 
     On the contrary, applying a Fast Transform preconditioner as per a preferred embodiment of this invention has far greater potential for parallelism than either multigrid or triangular solution algorithms, especially on GPUs. This has been studied in a paper by M. Ament, G. Knittel, D. Weiskopf, and W. Strasser, “A Parallel Preconditioned Conjugate Gradient Solver for the Poisson Problem on a Multi-GPU Platform”,  Euromicro Conference on Parallel, Distributed and Network - based Processing,  2010, incorporated herein by reference in its entirety. 
     We present below a method according to this invention, which provides the benefits of Fast Transform-based preconditioning over prior art methods such as multigrid, while overcoming the above stated limitations of Fast Poisson-based preconditioners. 
     Power Grid Modeling and Transient Analysis: 
     We place specific emphasis on transient analysis with a variable time-step, although those skilled in the art shall appreciate that the results are perfectly applicable in DC analysis as well. The typical model of a power grid for transient analysis is obtained (usually by a layout extraction tool) by modeling each wire segment (between two contacts) as a resistance in series with an inductance, and with capacitances to ground at both contact nodes. Let the electrical model of the power grid be composed of b composite R-L branches and N non-supply nodes. 
     By using the Modified Nodal Analysis (MNA) framework in such a linear circuit, we obtain the following system of differential equations [4]: 
     
       
         
           
             
               
                 
                   
                     
                       
                         
                           G 
                           ~ 
                         
                         ⁢ 
                         
                           x 
                           ⁡ 
                           
                             ( 
                             t 
                             ) 
                           
                         
                       
                       + 
                       
                         
                           C 
                           ~ 
                         
                         ⁢ 
                         
                           
                             x 
                             . 
                           
                           ⁡ 
                           
                             ( 
                             t 
                             ) 
                           
                         
                       
                     
                     = 
                     
                       e 
                       ⁡ 
                       
                         ( 
                         t 
                         ) 
                       
                     
                   
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   where 
                 
               
               
                 
                   ( 
                   1 
                   ) 
                 
               
             
             
               
                 
                   
                     G 
                     ~ 
                   
                   = 
                   
                     [ 
                     
                       
                         
                           0 
                         
                         
                           
                             A 
                             rl 
                           
                         
                       
                       
                         
                           
                             = 
                             
                               A 
                               rl 
                               T 
                             
                           
                         
                         
                           
                             R 
                             b 
                           
                         
                       
                     
                     ] 
                   
                 
               
               
                 
                   ( 
                   2 
                   ) 
                 
               
             
             
               
                 
                   
                     C 
                     ~ 
                   
                   = 
                   
                     [ 
                     
                       
                         
                           
                             C 
                             n 
                           
                         
                         
                           0 
                         
                       
                       
                         
                           0 
                         
                         
                           
                             L 
                             b 
                           
                         
                       
                     
                     ] 
                   
                 
               
               
                 
                   ( 
                   3 
                   ) 
                 
               
             
             
               
                 
                   
                     x 
                     ⁡ 
                     
                       ( 
                       t 
                       ) 
                     
                   
                   = 
                   
                     [ 
                     
                       
                         
                           
                             
                               v 
                               n 
                             
                             ⁡ 
                             
                               ( 
                               t 
                               ) 
                             
                           
                         
                       
                       
                         
                           
                             
                               i 
                               b 
                             
                             ⁡ 
                             
                               ( 
                               t 
                               ) 
                             
                           
                         
                       
                     
                     ] 
                   
                 
               
               
                 
                   ( 
                   4 
                   ) 
                 
               
             
             
               
                 
                   
                     e 
                     ⁡ 
                     
                       ( 
                       t 
                       ) 
                     
                   
                   = 
                   
                     [ 
                     
                       
                         
                           
                             
                               e 
                               n 
                             
                             ⁡ 
                             
                               ( 
                               t 
                               ) 
                             
                           
                         
                       
                       
                         
                           0 
                         
                       
                     
                     ] 
                   
                 
               
               
                 
                   ( 
                   5 
                   ) 
                 
               
             
           
         
       
     
     In the above system, A rl  is the N×b incidence matrix of the directed composite R-L branches (with elements a ij =±1 or a ij =0 depending on whether branch j leaves/enters or is not incident with node i), v n (t), i b (t) are the N×1 and b×1 vectors of node voltages and branch currents respectively, e n (t) is a N×1 vector of excitations from independent sources at the nodes, C n  is a N×N diagonal matrix of the node capacitances, and R b , L b  are diagonal b×b matrices of the resistances and self-inductances of the composite R-L branches. Using the Backward-Euler approximation we obtain from eq. (1) the following discretized system of linear algebraic equations: 
                       (       G   ~     +       C   ~       h   k         )     ⁢     x   ⁡     (     h   k     )         =       e   ⁡     (     h   k     )       +         C   ~       h   k       ⁢     x   ⁡     (     h     k   -   1       )                   (   6   )               
where h k , k=1, is the chosen time-step that may in general vary during the analysis. By block-matrix operations on the above system we obtain the following system of coupled recursive equations, as described in Chen et al. (cited above):
 
                       (             A   rl     ⁡     (       R   b     +       L   b       h   k         )         -   1       ⁢     A   rl   T       +       C   n       h   k         )     ⁢       v   n     ⁡     (     h   k     )         =           C   n       h   k       ⁢       v   n     ⁡     (     h     k   -   1       )         -     (             A   rl     ⁡     (       R   b     +       L   b       h   k         )         -   1       ⁢       L   b       h   k       ⁢       i   b     ⁡     (     h     k   -   1       )         +     e   ⁡     (     h   k     )                     (   7   )                       ⁢         i   b     ⁡     (     h   k     )       =           (       R   b     +       L   b       h   k         )       -   1       ⁢       L   b       h   k       ⁢       i   b     ⁡     (     h     k   -   1       )         +         (       R   b     +       L   b       h   k         )       -   1       ⁢     A   rl   T     ⁢       v   n     ⁡     (     h   k     )                     (   8   )               
At each time-step h k  we have to solve the N×N linear system eq. (7) with circuit matrix
 
             A   ≡             A   rl     ⁡     (       R   b     +       L   b       h   k         )         -   1       ⁢     A   rl   T       +       C   n       h   k               
and then find branch currents from eq. (8). If we neglect inductances and model the grid as an RC circuit, the system from eq. (3) reduces to the following recursive system:
 
                       (         A   rl     ⁢     R   b     -   1       ⁢     A   rl   T       +       C   n       h   k         )     ⁢       v   n     ⁡     (     h   k     )         =           C   n       h   k       ⁢       v   n     ⁡     (     h     k   -   1       )         +     e   ⁡     (     h   k     )                 (   9   )               
In both the above cases, the circuit matrix can be shown to be Symmetric and Positive Definite (SPD), which means that efficient direct or iterative methods such as the Cholesky factorization or the method of Conjugate Gradients can be employed for its solution.
 
     Iterative Linear Solution Methods: 
     The method of Conjugate Gradients constitutes a very attractive method for solving large SPD linear systems from a computational and memory usage perspective. It involves only inner products and matrix-vector products, while it only needs to keep 4 vectors in memory during its execution (due to a property of short recurrences). It also scales well with the dimension of the system and is a very good candidate for mapping onto parallel architectures. However, the convergence rate of CG is not predictable in its plain (non-preconditioned) form, which limits its adoption in the simulation of industrial and large-scale designs. 
     Regarding the convergence rate of CG, the required number of iterations (for a given initial guess and convergence tolerance) is bounded in terms of the spectral condition number κ 2 (A)=∥A∥ 2 ∥A −1 ∥ 2 ≧1—specifically, it is O(√{square root over (κ 2 (A))}), which for SPD matrices becomes 
                 κ   2     ⁡     (   A   )       =         λ   max     ⁡     (   A   )           λ   min     ⁡     (   A   )               
where λ max (A), λ min (A) are the maximum and minimum eigenvalues of A respectively. This means that convergence of CG is fast when κ 2 (A)≅1 and slow when κ 2 (A)&gt;&gt;1.
 
     Preconditioning is a technique which is used to transform the original linear system into one with more favorable spectral properties, and is essential for guaranteeing fast and robust convergence of CG. Algorithm 1 below describes the Preconditioned Conjugate Gradient method for the solution of an SPD linear system Ax=b. The preconditioner solve step Mz=r in every iteration (line 6) effectively modifies the CG algorithm to solve the system M −1 Ax=M −1 b, which has the same solution as the original one Ax=b. If M approximates A in some way, then M −1 =A −1  and κ 2 (M −1 A)≅κ 2 (I)=1, which makes the CG converge quickly. So the motivation behind preconditioning is to find a matrix M with the following properties: 1) the convergence rate of the preconditioned system M −1 Ax=M −1 b is fast, and 2) a linear system involving M (i.e. Mz=r) can be solved much more efficiently than the original system involving A (i.e. Ax=b). 
     Algorithm 1. 
     Preconditioned Conjugate Gradients method: 
     1. x=initial guess x (0)    
     2. r=b−Ax 
     3. iter=0 
     4. repeat 
     5. iter=iter+1 
     6. Solve Mz=r (Preconditioner Solve Step) 
     7. ρ=r·z 
     8. if iter==1 then 
     9. p=z 
     10. else 
     11. β=ρ/ρ1 
     12. p=z+βp 
     13. end 
     14. ρ1=ρ 
     15. q=Ap 
     16. α=ρ/(p·q) 
     17. x=x+αp 
     18. r=r−αq 
     19. until convergence 
     In general, the condition number κ 2 (A) and the number of iterations grows as a function of the matrix dimension N. It can be very beneficial if the circuit matrix A can be approximated well enough by a preconditioner M, so that κ 2 (M −1 A) and the number of iterations become independent of the dimension (i.e. they are bounded by a constant, O(1)), and at the same time the solution of the preconditioned systems Mz=r (which then effectively receives the whole burden of the algorithm) can be performed in O(N) or slightly higher number of operations. In that case the performance of PCG will be optimal or very close to optimal. The effect of good preconditioning is even more pronounced if the operations for the solution of Mz=r can be performed in parallel. Matrices arising from power grids can be well-approximated by preconditioners with special structure such that the number of iterations becomes bounded (or very slowly rising), while the systems Mz=r can be solved by applying a Fast Transform in a near-optimal number of operations in a sequential implementation, and even less operations in a parallel environment (owing to the large parallel potential of Fast Transforms as well as other parallelization opportunities). The next section describes the special form of the preconditioner matrices, and the solution of the corresponding linear systems Mz=r by a Fast Transform. 
     Fast Transform Solvers for 2D Networks: 
     Let M be a N×N block-tridiagonal matrix with m blocks of size n×n each (overall N=m·n), which has the following form: 
                   M   =     [           T   1             γ   1     ⁢   I                                                     γ   1     ⁢   I           T   2             γ   2     ⁢   I                                                 ⋮       ⋮       ⋮                                                   γ     m   -   2       ⁢   I           T     m   -   1               γ     m   -   1       ⁢   I                                                     γ     m   -   1       ⁢   I           T   m           ]             (   10   )               
where I is the n×n identity matrix and T i , i=1, . . . , m, are n×n tridiagonal matrices of the form:
 
     
       
         
           
             
               
                 
                   
                     
                       
                         
                           T 
                           i 
                         
                         = 
                         
                           [ 
                           
                             
                               
                                 
                                   
                                     α 
                                     i 
                                   
                                   + 
                                   
                                     β 
                                     i 
                                   
                                 
                               
                               
                                 
                                   - 
                                   
                                     α 
                                     i 
                                   
                                 
                               
                               
                                 
                                     
                                 
                               
                               
                                 
                                     
                                 
                               
                               
                                 
                                     
                                 
                               
                             
                             
                               
                                 
                                   - 
                                   
                                     α 
                                     i 
                                   
                                 
                               
                               
                                 
                                   
                                     2 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     
                                       α 
                                       i 
                                     
                                   
                                   + 
                                   
                                     β 
                                     i 
                                   
                                 
                               
                               
                                 
                                   - 
                                   
                                     α 
                                     i 
                                   
                                 
                               
                               
                                 
                                     
                                 
                               
                               
                                 
                                     
                                 
                               
                             
                             
                               
                                 
                                     
                                 
                               
                               
                                 ⋮ 
                               
                               
                                 ⋮ 
                               
                               
                                 ⋮ 
                               
                               
                                 
                                     
                                 
                               
                             
                             
                               
                                 
                                     
                                 
                               
                               
                                 
                                     
                                 
                               
                               
                                 
                                   - 
                                   
                                     α 
                                     i 
                                   
                                 
                               
                               
                                 
                                   
                                     2 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     
                                       α 
                                       i 
                                     
                                   
                                   + 
                                   
                                     β 
                                     i 
                                   
                                 
                               
                               
                                 
                                   - 
                                   
                                     α 
                                     i 
                                   
                                 
                               
                             
                             
                               
                                 
                                     
                                 
                               
                               
                                 
                                     
                                 
                               
                               
                                 
                                     
                                 
                               
                               
                                 
                                   - 
                                   
                                     α 
                                     i 
                                   
                                 
                               
                               
                                 
                                   
                                     α 
                                     i 
                                   
                                   + 
                                   
                                     β 
                                     i 
                                   
                                 
                               
                             
                           
                           ] 
                         
                       
                     
                   
                   
                     
                       
                         = 
                         
                           
                             α 
                             i 
                           
                           ⁢ 
                           
                               
                             
                               
                                 [ 
                                 
                                   
                                     
                                       1 
                                     
                                     
                                       
                                         - 
                                         1 
                                       
                                     
                                     
                                       
                                           
                                       
                                     
                                     
                                       
                                           
                                       
                                     
                                     
                                       
                                           
                                       
                                     
                                   
                                   
                                     
                                       
                                         - 
                                         1 
                                       
                                     
                                     
                                       2 
                                     
                                     
                                       
                                         - 
                                         1 
                                       
                                     
                                     
                                       
                                           
                                       
                                     
                                     
                                       
                                           
                                       
                                     
                                   
                                   
                                     
                                       
                                           
                                       
                                     
                                     
                                       ⋮ 
                                     
                                     
                                       ⋮ 
                                     
                                     
                                       ⋮ 
                                     
                                     
                                       
                                           
                                       
                                     
                                   
                                   
                                     
                                       
                                           
                                       
                                     
                                     
                                       
                                           
                                       
                                     
                                     
                                       
                                         - 
                                         1 
                                       
                                     
                                     
                                       2 
                                     
                                     
                                       
                                         - 
                                         1 
                                       
                                     
                                   
                                   
                                     
                                       
                                           
                                       
                                     
                                     
                                       
                                           
                                       
                                     
                                     
                                       
                                           
                                       
                                     
                                     
                                       
                                         - 
                                         1 
                                       
                                     
                                     
                                       1 
                                     
                                   
                                 
                                 ] 
                               
                               + 
                               
                                 
                                   β 
                                   i 
                                 
                                 ⁢ 
                                 I 
                               
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   11 
                   ) 
                 
               
             
           
         
       
     
     We will describe an algorithm for the solution of a linear system Mz=r with matrix M of the form from eq. (10), by the use of a Fast Transform solver in O(mn log n)=O(N log n) operations. Such a solution is based on the fact that the eigen-decomposition of the tridiagonal matrices T i  is known beforehand, and that the matrices of eigenvectors that diagonalize T i  are matrices that correspond to a Fast Transform. More specifically, it can be shown (as described in paper C. C. Christara, “Quadratic Spline Collocation Methods for Elliptic Partial Differential Equations”,  BIT Numerical Mathematics,  34(1):33-61, 1994, incorporated herein by reference in its entirety) that each T i  has n distinct eigenvalues λ i,j , j=1, . . . , n, which are given by: 
                     λ     i   ,   j       =         β   i     +     4   ⁢           ⁢     α   i     ⁢     sin   2     ⁢         (     j   -   1     )     ⁢   π       2   ⁢   n           =       β   i     +       α   i     ⁡     (       2   ⁢   cos   ⁢         (     j   -   1     )     ⁢   π     n       -   2     )                   (   12   )               
as well as a set of n orthonormal eigenvectors q j , j=1, . . . , n, with elements:
 
     
       
         
           
             
               
                 
                   
                     q 
                     
                       j 
                       , 
                       k 
                     
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             
                               
                                 1 
                                 n 
                               
                             
                             ⁢ 
                             cos 
                             ⁢ 
                             
                               
                                 
                                   ( 
                                   
                                     
                                       2 
                                       ⁢ 
                                       k 
                                     
                                     - 
                                     1 
                                   
                                   ) 
                                 
                                 ⁢ 
                                 
                                   ( 
                                   
                                     j 
                                     - 
                                     1 
                                   
                                   ) 
                                 
                                 ⁢ 
                                 π 
                               
                               
                                 2 
                                 ⁢ 
                                 n 
                               
                             
                           
                         
                         
                           
                             
                               j 
                               = 
                               1 
                             
                             , 
                             
                               k 
                               = 
                               1 
                             
                             , 
                             … 
                             ⁢ 
                             
                                 
                             
                             , 
                             n 
                           
                         
                       
                       
                         
                           
                             
                               
                                 2 
                                 n 
                               
                             
                             ⁢ 
                             cos 
                             ⁢ 
                             
                               
                                 
                                   ( 
                                   
                                     
                                       2 
                                       ⁢ 
                                       k 
                                     
                                     - 
                                     1 
                                   
                                   ) 
                                 
                                 ⁢ 
                                 
                                   ( 
                                   
                                     j 
                                     - 
                                     1 
                                   
                                   ) 
                                 
                                 ⁢ 
                                 π 
                               
                               
                                 2 
                                 ⁢ 
                                 n 
                               
                             
                           
                         
                         
                           
                             
                               j 
                               = 
                               2 
                             
                             , 
                             … 
                             ⁢ 
                             
                                 
                             
                             , 
                             n 
                             , 
                             
                               k 
                               = 
                               1 
                             
                             , 
                             … 
                             ⁢ 
                             
                                 
                             
                             , 
                             n 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   13 
                   ) 
                 
               
             
           
         
       
     
     Note that the q j  do not depend on the values of α i  and β i , and are the same for every matrix T i . If Q=[q 1 , . . . , q n ] denotes the matrix whose columns are the eigenvectors q j , then due to the eigen-decomposition of T i  we have Q T T i Q=Λ i =diag(λ 1,1 , . . . , λ i,n ). By exploiting this diagonalization of the matrices T i , the system Mz=r with M of the form of eq. (10) is equivalent to the following system (due to Q T Q=I): 
                       [           Q   T                                                 ⋱                                                 Q   T           ]     ⁢       M   ⁡     [         Q                                               ⋱                                               Q         ]       ⁡     [           Q   T                                                 ⋱                                                 Q   T           ]       ⁢   z     =         [           Q   T                                                 ⋱                                                 Q   T           ]     ⁢   r     ⇔             (   14   )                       ⁢           [           Λ   1             γ   1     ⁢   I                                                     γ   1     ⁢   I           Λ   2             γ   2     ⁢   I                                                 ⋮       ⋮       ⋮                                                   γ     m   -   2       ⁢   I           Λ     m   -   1               γ     m   -   1       ⁢   I                                                     γ     m   -   1       ⁢   I           Λ   m           ]     ⁢     z   ~       =     r   ~       ⁢     
     ⁢           ⁢   where             (   15   )                       ⁢         z   ~     =       [           Q   T                                                 ⋱                                                 Q   T           ]     ⁢   z       ,       r   ~     =       [           Q   T                                                 ⋱                                                 Q   T           ]     ⁢   r                 (   16   )               
If the N×1 vectors r, z, {tilde over (r)}, {tilde over (z)} are also partitioned into m blocks of size n×1 each, i.e.
 
                     r   =     [           r   1             ⋮             r   m           ]       ,     z   =     [           z   1             ⋮             z   m           ]       ,       r   ~     =     [             r   ~     1             ⋮               r   ~     m           ]       ,       z   ~     =     [             z   ~     1             ⋮               z   ~     m           ]               (   17   )               
then we have: {tilde over (r)} i =Q T r i  and {tilde over (z)} i =Q T z i             z i =Q{tilde over (z)} i , i=1, . . . , m.

     Each product Q T r i ={tilde over (r)} i  corresponds to a Discrete Cosine Transform of type-II (DCT-II) on r i , and each product Q{tilde over (z)} i =z i  corresponds to an Inverse Discrete Cosine Transform of type-II (IDCT-II) on {tilde over (z)} i . This means that the computation of the whole vector {tilde over (r)} from r amounts to m independent DCT-II transforms of size n, and the computation of the whole vector z from {tilde over (z)} amounts to m independent IDCT-II transforms of size n. A modification of Fast Fourier Transform (FFT) can be employed for each of the m independent DCT-II/IDCT-II transforms, giving a total operation count of O(mn log n)=O(N log n). 
     If now P is a permutation matrix that reorders the elements of a vector or the rows of a matrix as 
     1, n+1, 2n+1, . . . , (m−1)n+1, 2, n+2, 2n+2, . . . , (m−1)n+2, . . . , n, n+n, 2n+n, . . . , (m−1)n+n, and P T  is the inverse permutation matrix, then the system of eq. (15) is further equivalent to: 
                       P   ⁢           [           Λ   1             γ   1     ⁢   I                                                     γ   1     ⁢   I           Λ   2             γ   2     ⁢   I                                                 ⋮       ⋮       ⋮                                                   γ     m   -   2       ⁢   I           Λ     m   -   1               γ     m   -   1       ⁢   I                                                     γ     m   -   1       ⁢   I           Λ   m           ]     ⁢     P   T     ⁢   P   ⁢           ⁢     z   ~       =       P   ⁢           ⁢     r   ~       ⇔             (   18   )                     [             T   ~     1                                                                 T   ~     2                                                             ⋱                                                               T   ~     n           ]     ⁢       z   ~     P       =       r   ~     P       ⁢     
     ⁢   where           (   19   )                   T   ~     j     =     [           λ     1   ,   j             γ   1                                                   γ   1           λ     2   ,   j             γ   2                                                 ⋮       ⋮       ⋮                                                 γ     m   -   2             λ       m   -   1     ,   j             γ     m   -   1                                                     γ     m   -   1             λ     m   ,   j             ]             (   20   )               
and {tilde over (z)} P =P{tilde over (z)}, {tilde over (r)} P =P{tilde over (r)}. If the N×1 vectors {tilde over (z)} P , {tilde over (r)} P  are partitioned into n blocks {tilde over (z)} j   P , {tilde over (r)} j   P  of size m×1 each, then the system of eq. (19) effectively represents n independent tridiagonal systems T j {tilde over (z)} j   P ={tilde over (r)} j   P  of size m which can be solved w.r.t. the blocks {tilde over (z)} j   P , j=1, . . . , n (to produce the whole vector {tilde over (z)} P ) in a total of O(mn)=O(N) operations. For each such system the coefficient matrix of eq. (20) is known beforehand and is determined exclusively by the eigenvalues of eq. (12) and the values γ i  of matrix M, while the right-hand side (RHS) vector {tilde over (r)} j   P  is composed of specific components of (DCT-II)-transformed blocks of vector r. The equivalence of the system Mz=r, with M as in eq. (10), to the system of eq. (19) gives a procedure for fast solution of Mz=r which is described in Algorithm 2 below.
 
     Algorithm 2 (presented in  FIG. 7 ). We describe a Fast Transform algorithm, according to an embodiment, for the preconditioner solve step Mz=r, where M is of the form of eq. (10):
         1. Partition the RHS vector r into m blocks r i  of size n, and perform DCT-II transform (Q T r i ) on each block to obtain transformed vector {tilde over (r)}   2. Permute vector {tilde over (r)} by permutation P, which orders elements as 1, n+1, . . . , (m−1)n+1, 2, n+2, . . . , (m−1)n+2, . . . , n, n+n, . . . , (m−1)n+n, in order to obtain vector {tilde over (r)} P      3. Solve the n tridiagonal systems as in eq. (19) with known coefficient matrices from eq. (20), in order to obtain vector {tilde over (z)} P .   4. Apply inverse permutation P T  on vector {tilde over (z)} P  so as to obtain vector {tilde over (z)}.   5. Partition vector {tilde over (z)} into m blocks {tilde over (z)} i  of size n, and perform IDCT-II transform (Q{tilde over (z)} i ) on each block to obtain final solution vector z.       

     Fast Transform Solvers for 3D Networks: 
     The methodology above under “Fast Transform Solvers for 2D Networks” can be extended and applied for the solution of 3D networks. Let M be a N×N block-tridiagonal matrix with/blocks of size mn×mn each (overall N=l·m·n), where l is very small (typically between 2 and 8), since for power grid matrices it corresponds to the number of metal layers. For ease of presentation we will assume l=4 in the following, but the development is perfectly generalizable to an arbitrary number l. In particular, matrix M has the following form: 
                   M   =     [           M   1             γ   1     ⁢     I   mn                                           γ   1     ⁢     I   mn             M   2             γ   2     ⁢     I   mn                                           γ   2     ⁢     I   mn             M   3             γ   3     ⁢     I   mn                                           γ   3     ⁢     I   mn             M   4           ]             (   21   )               
where I mn  is the mn×mn identity matrix, and M i , i=1, 2, 3, 4, are alternating block-diagonal and block-tridiagonal mn×mn matrices with m blocks of size n×n which have the forms:
 
 M   i =diag( T   i   , . . . ,T   i ),  i= 1,3  (22)
 
                       M   i     =     [             (       α   i     +     β   i       )     ⁢     I   n               -     α   i       ⁢     I   n                                                       -     α   i       ⁢     I   n               (       2   ⁢           ⁢     α   i       +     β   i       )     ⁢     I   n               -     α   i       ⁢     I   n                                                   ⋮       ⋮       ⋮                                                               (       2   ⁢     α   i       +     β   i       )     ⁢     I   n               -     α   i       ⁢     I   n                                                       -     α   i       ⁢     I   n               (       α   i     +     β   i       )     ⁢     I   n             ]       ,     
     ⁢           ⁢     i   =   2     ,   4           (   23   )               
where I n  is the n×n identity matrix, and T i , i=1, 3 have the form of eq. (11). Thus, the eigenvalues and eigenvectors of the diagonal blocks of M i , i=1, 3 are the same as those of T i  and are given by eq. (12) and eq. (13) respectively. By a similar reasoning as in eq. (15), the linear system Mz=r with M of the form of eq. (21) is equivalent to the following:
 
     
       
         
           
             
               
                 
                   
                     
                       [ 
                       
                         
                           
                             
                               Q 
                               n 
                               T 
                             
                           
                           
                             
                                 
                             
                           
                           
                             
                                 
                             
                           
                         
                         
                           
                             
                                 
                             
                           
                           
                             ⋱ 
                           
                           
                             
                                 
                             
                           
                         
                         
                           
                             
                                 
                             
                           
                           
                             
                                 
                             
                           
                           
                             
                               Q 
                               n 
                               T 
                             
                           
                         
                       
                       ] 
                     
                     ⁢ 
                     
                       
                         M 
                         ⁡ 
                         
                           [ 
                           
                             
                               
                                 
                                   Q 
                                   n 
                                 
                               
                               
                                 
                                     
                                 
                               
                               
                                 
                                     
                                 
                               
                             
                             
                               
                                 
                                     
                                 
                               
                               
                                 ⋱ 
                               
                               
                                 
                                     
                                 
                               
                             
                             
                               
                                 
                                     
                                 
                               
                               
                                 
                                     
                                 
                               
                               
                                 
                                   Q 
                                   n 
                                 
                               
                             
                           
                           ] 
                         
                       
                       ⁡ 
                       
                         [ 
                         
                           
                             
                               
                                 Q 
                                 n 
                                 T 
                               
                             
                             
                               
                                   
                               
                             
                             
                               
                                   
                               
                             
                           
                           
                             
                               
                                   
                               
                             
                             
                               ⋱ 
                             
                             
                               
                                   
                               
                             
                           
                           
                             
                               
                                   
                               
                             
                             
                               
                                   
                               
                             
                             
                               
                                 Q 
                                 n 
                                 T 
                               
                             
                           
                         
                         ] 
                       
                     
                     ⁢ 
                     z 
                   
                   = 
                   
                     
                       
                         [ 
                         
                           
                             
                               
                                 Q 
                                 n 
                                 T 
                               
                             
                             
                               
                                   
                               
                             
                             
                               
                                   
                               
                             
                           
                           
                             
                               
                                   
                               
                             
                             
                               ⋱ 
                             
                             
                               
                                   
                               
                             
                           
                           
                             
                               
                                   
                               
                             
                             
                               
                                   
                               
                             
                             
                               
                                 Q 
                                 n 
                                 T 
                               
                             
                           
                         
                         ] 
                       
                       ⁢ 
                       r 
                     
                     ⇔ 
                   
                 
               
               
                 
                   ( 
                   24 
                   ) 
                 
               
             
             
               
                 
                   
                       
                   
                   ⁢ 
                   
                     
                       
                         
                           [ 
                           
                             
                               
                                 
                                   
                                     M 
                                     ~ 
                                   
                                   1 
                                 
                               
                               
                                 
                                   
                                     γ 
                                     1 
                                   
                                   ⁢ 
                                   
                                     I 
                                     mn 
                                   
                                 
                               
                               
                                 
                                     
                                 
                               
                               
                                 
                                     
                                 
                               
                               
                                 
                                     
                                 
                               
                             
                             
                               
                                 
                                   
                                     γ 
                                     1 
                                   
                                   ⁢ 
                                   
                                     I 
                                     mn 
                                   
                                 
                               
                               
                                 
                                   M 
                                   2 
                                 
                               
                               
                                 
                                   
                                     γ 
                                     2 
                                   
                                   ⁢ 
                                   
                                     I 
                                     mn 
                                   
                                 
                               
                               
                                 
                                     
                                 
                               
                               
                                 
                                     
                                 
                               
                             
                             
                               
                                 
                                     
                                 
                               
                               
                                 
                                   
                                     
                                       γ 
                                       2 
                                     
                                     ⁢ 
                                     
                                       I 
                                       mn 
                                     
                                   
                                   ⁢ 
                                   
                                       
                                   
                                 
                               
                               
                                 
                                   
                                     M 
                                     ~ 
                                   
                                   3 
                                 
                               
                               
                                 
                                   
                                     γ 
                                     3 
                                   
                                   ⁢ 
                                   
                                     I 
                                     mn 
                                   
                                 
                               
                               
                                 
                                     
                                 
                               
                             
                             
                               
                                 
                                     
                                 
                               
                               
                                 
                                     
                                 
                               
                               
                                 
                                   
                                     
                                       γ 
                                       3 
                                     
                                     ⁢ 
                                     
                                       I 
                                       mn 
                                     
                                   
                                   ⁢ 
                                   
                                       
                                   
                                 
                               
                               
                                 
                                   M 
                                   4 
                                 
                               
                               
                                 
                                     
                                 
                               
                             
                           
                           ] 
                         
                         ⁢ 
                         
                           z 
                           ~ 
                         
                       
                       = 
                       
                         r 
                         ~ 
                       
                     
                     ⁢ 
                     
                       
 
                     
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     
                       
                         
                           where 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           
                             
                               M 
                               ~ 
                             
                             i 
                           
                         
                         = 
                         
                           diag 
                           ⁡ 
                           
                             ( 
                             
                               
                                 Λ 
                                 i 
                               
                               , 
                               … 
                               ⁢ 
                               
                                   
                               
                               , 
                               
                                 Λ 
                                 i 
                               
                             
                             ) 
                           
                         
                       
                       , 
                       
                         i 
                         = 
                         1 
                       
                       , 
                       3 
                       , 
                       and 
                     
                   
                 
               
               
                 
                   ( 
                   25 
                   ) 
                 
               
             
             
               
                 
                   
                       
                   
                   ⁢ 
                   
                     
                       
                         z 
                         ~ 
                       
                       = 
                       
                         
                           [ 
                           
                             
                               
                                 
                                   Q 
                                   n 
                                   T 
                                 
                               
                               
                                 
                                     
                                 
                               
                               
                                 
                                     
                                 
                               
                             
                             
                               
                                 
                                     
                                 
                               
                               
                                 
                                     
                                 
                               
                               
                                 
                                     
                                 
                               
                             
                             
                               
                                 
                                     
                                 
                               
                               
                                 
                                     
                                 
                               
                               
                                 
                                   Q 
                                   n 
                                   T 
                                 
                               
                             
                           
                           ] 
                         
                         ⁢ 
                         z 
                       
                     
                     , 
                     
                       
                         r 
                         ~ 
                       
                       = 
                       
                         
                           [ 
                           
                             
                               
                                 
                                   Q 
                                   n 
                                   T 
                                 
                               
                               
                                 
                                     
                                 
                               
                               
                                 
                                     
                                 
                               
                             
                             
                               
                                 
                                     
                                 
                               
                               
                                 
                                     
                                 
                               
                               
                                 
                                     
                                 
                               
                             
                             
                               
                                 
                                     
                                 
                               
                               
                                 
                                     
                                 
                               
                               
                                 
                                   Q 
                                   n 
                                   T 
                                 
                               
                             
                           
                           ] 
                         
                         ⁢ 
                         r 
                       
                     
                   
                 
               
               
                 
                   ( 
                   26 
                   ) 
                 
               
             
           
         
       
     
     If the N×1 vectors r, z, {tilde over (r)}, {tilde over (z)} are themselves partitioned into lm sub-vectors (blocks) of size n×1 each, i.e. 
                     r   =     [           r   1             ⋮             r   im           ]       ,     z   =     [           z   1             ⋮             z   im           ]       ,       r   ~     =     [             r   ~     1             ⋮               r   ~     im           ]       ,       z   ~     =     [             z   ~     1             ⋮               z   ~     im           ]               (   27   )               
then we have {tilde over (r)} i =Q n   T r i , and {tilde over (z)} i =Q n   T z i             z i =Q n {tilde over (z)} i , i=1, . . . , lm. If P is again the permutation matrix of size mn×mn that reorders the elements of a vector or the rows of a matrix as 1, n+1, . . . , (m−1)n+1, 2, n+2, . . . , (m−1)n+2, . . . , n, n+n, . . . , (m−1)n+n, and P 1 , P 1   T  denote the block-diagonal N×N permutation matrices P 1 =diag(P,P,P,P) and P 1   T =diag(P T ,P T ,P T ,P T ) then the system from eq. (25) is further equivalent to:

                         P   1     ⁡     [             M   ~     1             γ   1     ⁢     I   mn                                           γ   1     ⁢     I   mn             M   2             γ   2     ⁢     I   mn                                           γ   2     ⁢     I   mn               M   3     ~             γ   3     ⁢     I   mn                                           γ   3     ⁢     I   mn             M   4           ]       ⁢     P   1   T     ⁢     P   1     ⁢     z   ~       =         P   1     ⁢     r   ~       ⇔             (   28   )                     [           D   1             γ   1     ⁢     I   mn                                           γ   1     ⁢     I   mn             D   2             γ   2     ⁢     I   mn                                           γ   2     ⁢     I   mn             D   3             γ   3     ⁢     I   mn                                           γ   3     ⁢     I   mn             D   4           ]     ⁢       z   ~       P   1         =       r   ~       P   1         ⁢     
     ⁢   where           (   29   )                     D   i     =     diag   ⁡     (         λ     i   ,   1       ⁢     I   m       ,   …   ⁢           ,       λ     i   ,   n       ⁢     I   m         )         ,     i   =   1     ,   3     ⁢     
     ⁢         D   i     =     diag   ⁡     (       T   i     ,   …   ⁢           ,     T   i       )         ,     i   =   2     ,   4             (   30   )               
and {tilde over (z)} P     1   =P 1 {tilde over (z)}, {tilde over (r)} P     1   =P 1 {tilde over (r)}. In the above, T i , i=2, 4, are m×m tridiagonal matrices of the form of eq. (11), each having m distinct eigenvalues as in eq. (12) (with m in place of n), and m orthonormal eigenvectors as in eq. (13) (with m in place of n). If Q m =[q 1 , . . . , q m ] is the common matrix of eigenvectors for T i , i=2, 4, and Q m   T T i Q m =Λ i =diag(λ i,1 , . . . , λ i,m ) is the corresponding diagonalization, then the system of eq. (29) is further equivalent to:
 
                         [           Q   m   T                                                                                                       Q   m   T           ]     ⁡     [           D   1             γ   1     ⁢     I   mn                                           γ   1     ⁢     I   mn             D   2             γ   2     ⁢     I   mn                                           γ   2     ⁢     I   mn             D   3             γ   3     ⁢     I   mn                                           γ   3     ⁢     I   mn             D   4           ]       ⁡     [           Q   m                                                                                                       Q   m           ]       ×           (   31   )                 ×     [           Q   m   T                                                                                                       Q   m   T           ]     ⁢       z   ~       P   1         =         [           Q   m   T                                                                                                       Q   m   T           ]     ⁢       r   ~       P   1         ⇔             (   32   )                     [           D   1             γ   1     ⁢     I   mn                                           γ   1     ⁢     I   mn               D   ~     2             γ   2     ⁢     I   mn                                           γ   2     ⁢     I   mn             D   3             γ   3     ⁢     I   mn                                           γ   3     ⁢     I   mn               D   ~     4           ]     ⁢     z     ~   ~         =     r     ~   ~         ⁢     
     ⁢         where   ⁢           ⁢       D   ~     i       =     diag   ⁡     (       Λ   i     ,   …   ⁢           ,     Λ   i       )         ,     i   =   2     ,   4   ,   and             (   33   )                   z     ~   ~       =       [           Q   m   T                                                                                                       Q   m   T           ]     ⁢       z   ~       P   1           ,       r     ~   ~       =       [           Q   m   T                                                                                                       Q   m   T           ]     ⁢       r   ~       P   1                   (   34   )               
In a similar fashion as previously, the N×1 vectors {tilde over (r)} P     1   , {tilde over (z)} P     1   , {tilde over ({tilde over (r)})}, {tilde over ({tilde over (z)})} can be partitioned into ln sub-vectors of size m×1 each, and then the computation of {tilde over ({tilde over (r)})} from {tilde over (r)} P     1    amounts to ln independent DCT-II transforms of size m, and the computation of {tilde over (z)} P     1    from {tilde over ({tilde over (z)})} amounts to ln independent IDCT-II transforms of size m, leading to a serial operation count of O(lnm log m)=O(N log m).
 
If we now denote by P 2  the N×N permutation matrix that reorders the elements of a vector or the rows of a matrix as
 
     1, mn+1, . . . , (l−1)mn+1, 2, mn+2, . . . , (l−1)mn+2, . . . , mn, mn+mn, . . . , (l−1)mn+mn, 
     and by P 2   T  the inverse permutation matrix, then the system of eq. (33) is eventually equivalent to: 
                           ⁢       P   2     =         [           D   1             γ   1     ⁢     I   mn                                           γ   1     ⁢     I   mn               D   ~     2             γ   2     ⁢     I   mn                                           γ   2     ⁢     I   mn             D   3             γ   3     ⁢     I   mn                                           γ   3     ⁢     I   mn               D   ~     4           ]     ⁢     P   2   T     ⁢     P   2     ⁢     z     ~   ~         =         P   2     ⁢     r     ~   ~         ⇔                 (   35   )                     diag   ⁡     (         T   ~       1   ,   1       ,       T   ~       1   ,   2       ,   …   ⁢           ,       T   ~       1   ,   m       ,       T   ~       2   ,   1       ,   …   ⁢           ,       T   ~       2   ,   m       ,   …   ⁢           ,       T   ~       n   ,   m         )       ⁢       z     ~   ~         P   2         =       r     ~   ~         P   2         ⁢     
     ⁢           ⁢   where           (   36   )                       ⁢           T   ~       i   ,   j       =     [           λ     1   ,   j             γ   1                                       γ   1           λ     2   ,   j             γ   2                                       γ   2           λ     3   ,   i             γ   3                                       γ   3           λ     4   ,   j             ]       ,     i   =   1     ,   …   ⁢           ,   n   ,     j   =   1     ,   …   ⁢           ,   m             (   37   )               
and {tilde over ({tilde over (z)})} P     2   =P 2 {tilde over ({tilde over (z)})}, {tilde over ({tilde over (r)})} P     2   =P 2 {tilde over ({tilde over (r)})}. If the N×1 vectors {tilde over ({tilde over (z)})} P     2   , {tilde over ({tilde over (r)})} P     2    are partitioned into mn sub-vectors {tilde over ({tilde over (z)})} (i−1)m+j   P     2   , {tilde over ({tilde over (r)})} (i−1)m+j   P     2    of size l×1 each (i=1, . . . , n, j=1, . . . , m), then the system from eq. (36) effectively represents mn independent tridiagonal systems {tilde over (T)} i,j {tilde over ({tilde over (z)})} (i−1)m+j   P     2   ={tilde over ({tilde over (r)})} (i−1)m+j   P     2    of size l which can be solved w.r.t. the sub-vectors {tilde over ({tilde over (z)})} (i−1)m+j   P     2    (to produce the whole vector {tilde over ({tilde over (z)})} P     2   ) in a total of O(lmn)=O(N) serial operations. For each such system, the coefficient matrix of eq. (37) is known beforehand and is determined exclusively by the eigenvalues given in eq. (12) and the values γ i  of the matrix M. The equivalence of the system Mz=r, with M as in eq. (21), to the system of eq. (36), gives a procedure for solution of Mz=r in a near-optimal number of O(N)+O(N(log n+log m))=O(N log(nm)) operations, which is described in Algorithm 3 below. Note that apart from the near-optimal serial complexity, both algorithms entail a great amount of task-level parallelism. The in DCT-II/IDCT-II transforms and the n tridiagonal systems of Algorithm 3, as well as the lm first-level DCT-II/IDCT-II transforms respectively, the ln second-level DCT-II/IDCT-II transforms, and the inn tridiagonal systems of Algorithm 3 are completely independent to each other and can be executed in parallel. Furthermore, the FFT is a highly-parallel algorithm by itself, allowing for further acceleration of the individual transforms when executed on parallel platforms.
 
     Algorithm 3 (presented in  FIG. 8 ). Fast Transform algorithm for the preconditioner solve step Mz=r, where M is of the form of eq. (21):
         1. Partition the RHS vector r into lm sub-vectors r i  of size n, and perform DCT-II transform (Q n   T r i ) on each sub-vector to obtain transformed vector {tilde over (r)}.   2. Partition vector {tilde over (r)} into l sub-vectors {tilde over (r)} i  of size mn, and permute each sub-vector by permutation P, which orders elements as 1, n+1, . . . , (m−1)n+1, 2, n+2, . . . , (m−1)n+2, . . . , n, n+n, . . . , (m−1)n+n, in order to obtain vector {tilde over (r)} P     1   .   3. Partition vector {tilde over (r)} P     1    into ln sub-vectors {tilde over (r)} i   P     1    of size m, and perform DCT-II transform (Q m   T {tilde over (r)} i   P     1   ) on each sub-vector to obtain transformed vector {tilde over ({tilde over (r)})}.   4. Permute vector {tilde over ({tilde over (r)})} in order to obtain vector {tilde over ({tilde over (r)})} P     2   , by applying permutation P 2 , which orders elements as 1, mn+1, 2mn+1, . . . , (l−1)mn+1, 2, mn+2, 2mn+2, . . . , (l−1)mn+2, . . . , mn, . . . , (l−1)mn+mn   5. Solve the mn tridiagonal systems (36) with known coefficient matrices from eq. (37), in order to obtain vector {tilde over ({tilde over (z)})} P     2   .   6. Apply inverse permutation P 2   T  on vector {tilde over ({tilde over (z)})} P     2    so as to obtain vector {tilde over ({tilde over (z)})}.   7. Partition vector {tilde over ({tilde over (z)})} into ln sub-vectors {tilde over ({tilde over (z)})} P     i    of size m, and perform IDCT-II transform (Q m {tilde over ({tilde over (z)})} i ) on each sub-vector to obtain vector {tilde over (z)} P     1   .   8. Partition vector {tilde over (z)} P     1    into l sub-vectors {tilde over (z)} i   P     1    of size mn, and apply inverse permutation P T  on each sub-vector to obtain vector {tilde over (z)}.   9. Partition vector {tilde over (z)} into lm sub-vectors {tilde over (z)} i  of size n, and perform IDCT-II transform (Q n {tilde over (z)} i ) on each sub-vector to obtain final solution vector z.       

     The intuition behind preconditioner&#39;s formulation is to create a matrix M that will approximate the circuit matrix A as faithfully as possible, while at the same time enable the utilization of efficient algorithms for the solution of systems Mz=r. We have developed such an algorithm based on a Fast Transform solver in the previous section for a class of matrices with special structure. This section will describe the construction of a preconditioner with such structure from a given power grid by exploiting its spatial geometry. 
     Practical power grids are created as orthogonal wire meshes with very regular spatial geometries, with possibly some irregularities imposed by design constraints (e.g. some missing connections between adjacent nodes), and arranged in a few—typically 2 to 6—metal layers of alternating routing directions (horizontal and vertical). Due to the presence of vias between successive metal layers, the actual grid has the structure of a 3D mesh, with very few planes along the third dimension. However, as it was observed in Feng et al. (cited above), electrical resistances of vias are usually much smaller than wire resistances; leading to voltage drops much less than 1 mV. Also, data in Shi et al. (cited above) show that almost all circuit elements (mainly resistances) in each metal layer have the same values (with few differences due to grid irregularities). Based on these observations, we create a preconditioner matrix that approximates the circuit matrix of the power grid by a process of regularization of the 3D power grid to a regular 2D grid. The regularization process is described in Algorithm 4 below. 
     Algorithm 4 (presented in  FIG. 9 ). We describe an algorithm for regularizing a 3D irregular to 2D regular power grid for preconditioning, according to an embodiment:
         1. Determine the distinct x- and y-coordinates of all nodes in the different layers of the 3D grid, and take their Cartesian product to specify the location of the nodes in the regular 2D grid.   2. By disregarding via resistances between layers, collapse the 3D grid onto the regular 2D grid by adding together all horizontal branch conductances       

     
       
         
           
             
               g 
               h 
             
             ≡ 
             
               1 
               
                 
                   r 
                   h 
                 
                 + 
                 
                   
                     l 
                     h 
                   
                   
                     h 
                     k 
                   
                 
               
             
           
         
       
         
         
           
             connected in parallel between adjacent nodes in the x-direction of the 2D grid, and all vertical branch conductances 
           
         
       
    
     
       
         
           
             
               g 
               v 
             
             ≡ 
             
               1 
               
                 
                   r 
                   v 
                 
                 + 
                 
                   
                     l 
                     v 
                   
                   
                     h 
                     k 
                   
                 
               
             
           
         
       
         
         
           
             connected in parallel between adjacent nodes in the y-direction of the 2D grid (where r h , l h  denote the resistance and inductance of horizontal branches, and r v , l v  denote the resistance and inductance of vertical branches—the inductances might not be present in the model). If a conductance of the 3D grid occupies multiple nodes of the regular 2D grid, it is decomposed into a corresponding number of pieces. The node capacitances corresponding to the same regular grid nodes are also added together during the collapsing. 
             3. In the regular 2D grid, substitute horizontal branch conductances by their average value in each horizontal rail, and vertical branch conductances by their average value in each vertical slice (a slice is the part of a rail between two adjacent horizontal rails). 
             4. Substitute node capacitances in each horizontal rail by their average value as well. 
             5. Amortize the total sum of pad conductances of a specific horizontal rail (in the regular 2D grid) to all nodes of this rail, i.e. assume that all nodes of the i-th horizontal rail have pad conductance 
           
         
       
    
     
       
         
           
             
               
                 
                   g 
                   _ 
                 
                 i 
                 p 
               
               = 
               
                 
                   
                     ( 
                     
                       ∑ 
                       
                         g 
                         p 
                       
                     
                     ) 
                   
                   i 
                 
                 n 
               
             
             , 
           
         
       
         
         
           
             where (Σg p ) i  is the sum of the actual pad conductances attached to nodes of the i-th horizontal rail. 
           
         
       
    
       FIG. 1  depicts a 3D drawing of a 3-layer power delivery network  101  with m=3 horizontal rails  111 ,  112 ,  113  and n=3 vertical rails  121 ,  122 ,  123  in likewise-routed layers.  FIG. 2  shows the 2D regular grid  201  that results from the regularization process (Algorithm 4) used to construct the preconditioner matrix, which collapses the 3D network  101  to a 2D one by assuming ideal via contacts  131 . If we use the depicted natural node numbering 1 through 9 (proceeding horizontally, since this is usually the routing direction of the lowest-level metal layer), the matrix 
                     A   rl     ⁡     (       R   b     +       L   b       h   k         )         -   1       ⁢     A   rl   T       +       C   n       h   k             
that corresponds to the regular 2D grid will be the following block-tridiagonal matrix:
 
                   [           T   1             -     g   1   v       ⁢   I                             -     g   1   v       ⁢   I           T   2             -     g   2   v       ⁢   I                             -     g   2   v       ⁢   I           T   3           ]           (   38   )               
where T 1 , T 2 , T 3  are 3×3 tridiagonal matrices (each one corresponding to a horizontal rail of the 2D grid) which have the form:
 
     
       
         
           
             
               
                 
                   
                     T 
                     1 
                   
                   = 
                   
                     [ 
                     
                       
                         
                           
                             
                               g 
                               1 
                               h 
                             
                             + 
                             
                               g 
                               1 
                               v 
                             
                             + 
                             
                               
                                 g 
                                 _ 
                               
                               1 
                               p 
                             
                             + 
                             
                               
                                 c 
                                 1 
                               
                               
                                 h 
                                 k 
                               
                             
                           
                         
                         
                           
                             - 
                             
                               g 
                               1 
                               h 
                             
                           
                         
                         
                           
                               
                           
                         
                       
                       
                         
                           
                             - 
                             
                               g 
                               1 
                               h 
                             
                           
                         
                         
                           
                             
                               2 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               
                                 g 
                                 1 
                                 h 
                               
                             
                             + 
                             
                               g 
                               1 
                               v 
                             
                             + 
                             
                               
                                 g 
                                 _ 
                               
                               1 
                               p 
                             
                             + 
                             
                               
                                 c 
                                 1 
                               
                               
                                 h 
                                 k 
                               
                             
                           
                         
                         
                           
                             - 
                             
                               g 
                               1 
                               h 
                             
                           
                         
                       
                       
                         
                           
                               
                           
                         
                         
                           
                             - 
                             
                               g 
                               1 
                               h 
                             
                           
                         
                         
                           
                             
                               g 
                               1 
                               h 
                             
                             + 
                             
                               g 
                               1 
                               v 
                             
                             + 
                             
                               
                                 g 
                                 _ 
                               
                               1 
                               p 
                             
                             + 
                             
                               
                                 c 
                                 1 
                               
                               
                                 h 
                                 k 
                               
                             
                           
                         
                       
                     
                     ] 
                   
                 
               
               
                 
                   ( 
                   39 
                   ) 
                 
               
             
             
               
                 
                   
                     T 
                     2 
                   
                   = 
                   
                     [ 
                     
                       
                         
                           
                             
                               g 
                               2 
                               h 
                             
                             + 
                             
                               g 
                               1 
                               v 
                             
                             + 
                             
                               g 
                               2 
                               v 
                             
                             + 
                             
                               
                                 c 
                                 2 
                               
                               
                                 h 
                                 k 
                               
                             
                           
                         
                         
                           
                             - 
                             
                               g 
                               2 
                               h 
                             
                           
                         
                         
                           
                               
                           
                         
                       
                       
                         
                           
                             - 
                             
                               g 
                               2 
                               h 
                             
                           
                         
                         
                           
                             
                               2 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               
                                 g 
                                 2 
                                 h 
                               
                             
                             + 
                             
                               g 
                               1 
                               v 
                             
                             + 
                             
                               g 
                               2 
                               v 
                             
                             + 
                             
                               
                                 c 
                                 2 
                               
                               
                                 h 
                                 k 
                               
                             
                           
                         
                         
                           
                             - 
                             
                               g 
                               2 
                               h 
                             
                           
                         
                       
                       
                         
                           
                               
                           
                         
                         
                           
                             - 
                             
                               g 
                               2 
                               h 
                             
                           
                         
                         
                           
                             
                               g 
                               2 
                               h 
                             
                             + 
                             
                               g 
                               1 
                               v 
                             
                             + 
                             
                               g 
                               2 
                               v 
                             
                             + 
                             
                               
                                 c 
                                 2 
                               
                               
                                 h 
                                 k 
                               
                             
                           
                         
                       
                     
                     ] 
                   
                 
               
               
                 
                   ( 
                   40 
                   ) 
                 
               
             
             
               
                 
                   
                       
                   
                   ⁢ 
                   
                     
                       T 
                       3 
                     
                     = 
                     
                       [ 
                       
                         
                           
                             
                               
                                 g 
                                 3 
                                 h 
                               
                               + 
                               
                                 g 
                                 2 
                                 v 
                               
                               + 
                               
                                 
                                   c 
                                   3 
                                 
                                 
                                   h 
                                   k 
                                 
                               
                             
                           
                           
                             
                               - 
                               
                                 g 
                                 3 
                                 h 
                               
                             
                           
                           
                             
                                 
                             
                           
                         
                         
                           
                             
                               - 
                               
                                 g 
                                 3 
                                 h 
                               
                             
                           
                           
                             
                               
                                 2 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 
                                   g 
                                   3 
                                   h 
                                 
                               
                               + 
                               
                                 g 
                                 2 
                                 v 
                               
                               + 
                               
                                 
                                   c 
                                   3 
                                 
                                 
                                   h 
                                   k 
                                 
                               
                             
                           
                           
                             
                               - 
                               
                                 g 
                                 3 
                                 h 
                               
                             
                           
                         
                         
                           
                             
                                 
                             
                           
                           
                             
                               - 
                               
                                 g 
                                 3 
                                 h 
                               
                             
                           
                           
                             
                               
                                 g 
                                 3 
                                 h 
                               
                               + 
                               
                                 g 
                                 2 
                                 v 
                               
                               + 
                               
                                 
                                   c 
                                   3 
                                 
                                 
                                   h 
                                   k 
                                 
                               
                             
                           
                         
                       
                       ] 
                     
                   
                 
               
               
                 
                   ( 
                   41 
                   ) 
                 
               
             
           
         
       
     
     In the above, g i   h  is the average horizontal conductance in the i-th horizontal rail, g i   v  is the average vertical conductance in the i-th horizontal slice, and c i  is the average node capacitance in the i-th horizontal rail. Also h k  is the current analysis time-step (possibly variable), 
               g   p     ≡     1       r   p     +       l   p       h   k                 
is the parasitic conductance of the supply pads (r p  and l p  denote the resistance and inductance of the supply pads respectively), and
 
     
       
         
           
             
               
                 g 
                 _ 
               
               1 
               p 
             
             = 
             
               
                 
                   g 
                   p 
                 
                 3 
               
               . 
             
           
         
       
     
     As we can observe, the form of the above matrix is identical to eq. (10), which means that we have obtained a preconditioner M with an exact form that can be efficiently solved by the application of a Fast Transform. Moreover, it has to be mentioned that we have found that in practice it is usually better to amortize the total sum of pad conductances of a specific horizontal rail (in the regular 2D grid) to all nodes of this rail (step 4 in Algorithm 4). This also has the beneficial effect of making the preconditioner M non-singular in the case of DC analysis (where capacitances and inductances are absent). It is not difficult to generalize the procedure to an arbitrary m×n power grid. In that case, the preconditioner will comprise m blocks of size n×n and have the form of eq. (10), where 
     
       
         
           
             
               
                 α 
                 i 
               
               = 
               
                 g 
                 i 
                 h 
               
             
             , 
             
               
                 β 
                 i 
               
               = 
               
                 
                   g 
                   i 
                   v 
                 
                 + 
                 
                   g 
                   
                     i 
                     - 
                     1 
                   
                   v 
                 
                 + 
                 
                   
                     g 
                     _ 
                   
                   i 
                   p 
                 
                 + 
                 
                   
                     c 
                     i 
                   
                   
                     h 
                     k 
                   
                 
               
             
             , 
             
               
                 γ 
                 i 
               
               = 
               
                 - 
                 
                   g 
                   i 
                   v 
                 
               
             
             , 
             
               
 
             
             ⁢ 
             
               i 
               = 
               1 
             
             , 
             … 
             ⁢ 
             
                 
             
             , 
             
               m 
               ⁢ 
               
                   
               
               ⁢ 
               
                 
                   ( 
                   
                     
                       with 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       
                         g 
                         0 
                         v 
                       
                     
                     = 
                     
                       
                         g 
                         m 
                         v 
                       
                       = 
                       0 
                     
                   
                   ) 
                 
                 . 
               
             
           
         
       
     
     According to a preferred embodiment, the preconditioner construction requires only a simple parsing of the netlist of the electrical circuit representing the power grid, where the name of each node in the input netlist is chosen to contain geometry information in its suffix. More specifically, as shown in  FIG. 3 , the netlist  301  contains the x ( 310 ) and y ( 320 ) coordinates as well as the number of the corresponding metal layer ( 330 ). These coordinates and metal numbers can be trivially passed to the netlist by the layout extraction tool that produces the model of the power grid, since the said tool will typically have access to this information in the course of processing the polygons that comprise the power grid. Other variations of formatting this information to the netlist may include adding the coordinates and layer numbers (or layer names), in the form of comments or ‘pragmas’ in the netlist, next to the electrical elements they correspond to. In any case, parsing of the input netlist is of complexity O(N) (considering that the number of electrical elements is of the same order as the number of nodes N), which is inexpensive since it represents a one-time cost, roughly comparable to one iteration (and amortized over multiple iterations) of the CG method. 
     During transient analysis with variable time-step (which is almost always used in practical simulation scenarios), the construction of the preconditioner matrix has to be repeated at every change of time-step in the same O(N) operations. This is also necessary for all other known preconditioners, but is in fact very expensive for some of them e.g. multigrid preconditioners. However, a considerable simplification is possible in the very common case of resistive or RC-only electrical models (i.e. when inductances are absent from the model) since the change of time-step does not affect any actions in the construction procedure, and thus there is no need for a full reconstruction (but only, actually, an update in the eigenvalues from eq. (12) of the preconditioner matrix). 
     Advantages for 2D Networks: 
     Compared to the preconditioning mechanisms presented in Zhao et al. and Yang et al. (both cited above), the proposed preconditioner offers significant advantages. First, it provides a near-optimal method for solving the preconditioner solve step. Compared with the preconditioner presented in Zhao et al. that has a complexity of O(N 1.5 ), our method reduces the required complexity to O(N log n) operations in the case of a 2D network. In addition, it is amenable to massive parallelism and as a result execution times can be greatly reduced if parallel architectures are utilized. This is not the case for the preconditioner presented in Zhao et al., which requires the solution of triangular systems. Triangular linear systems provide limited parallelism and as a result the corresponding solution algorithms are not able to utilize parallel architectures efficiently. The second advantage of the preconditioner in this invention is that it can handle very efficiently every power delivery network design. The preconditioner presented in Yang et al. requires the existence of special areas in the grid with zero voltage drop as boundary condition, in order to formulate so-called “Poisson blocks” with Toeplitz matrix structure. This assumption can hinder preconditioner&#39;s applicability and efficiency for general power delivery networks. 
     Moreover, apart from the near-optimal complexity of solving the systems Mz=r, one other salient feature of the proposed preconditioner is that there is no need for explicit storage of the preconditioner matrix M. As it is easily observed, only the eigenvalues from eq. (12) and the values γ i −g 1   v  of M are necessary in the execution of Algorithm 2 (for formulation of the tridiagonal systems from eq. (19) with coefficient matrices from eq. (20)), and thus only storage for those mn+(m−1) values needs to be allocated. A small memory footprint is very important for mapping the algorithm onto parallel computing architectures with limited available memory space such as GPUs. 
     Extending to 3D Power Delivery Networks: 
     In case that via resistances can not be ignored, the proposed methodology can be extended to accommodate for 3D networks. Referring back to  FIG. 1 , we can take the average resistance among the rails from each metal layer, assuming that there exist vias connecting every node from layer i with the corresponding node in layer i+1, and utilize Algorithm 5 below to create a regular 3D power grid. 
     Algorithm 5 (presented in  FIG. 10 ). We provide an algorithm for regularizing a 3D irregular to 3D regular power grid for preconditioning, according to an embodiment:
         1. Determine the distinct x- and y-coordinates of all nodes in the different layers of the 3D grid, and take their Cartesian product to specify the location of the nodes in the regular 3D grid.   2. Substitute all branch conductances       

     
       
         
           
             
               g 
               i 
             
             ≡ 
             
               1 
               
                 
                   r 
                   i 
                 
                 + 
                 
                   
                     l 
                     i 
                   
                   
                     h 
                     k 
                   
                 
               
             
           
         
       
         
         
           
             in each metal layer by their average value within this layer (the inductances l i  might not be present in the model). 
             3. Substitute node capacitances c i  in each layer by their average value as well. 
             4. Substitute the average value in all via conductances connecting two successive metal layers. 
           
         
       
    
     According to a preferred embodiment in the 3D case, with reference to  FIG. 4 , the resulting regular 3D grid  401  is used for preconditioning and the corresponding circuit matrix has the following form: 
     
       
         
           
             
               
                 
                   
                     M 
                     = 
                     
                       [ 
                       
                         
                           
                             
                               M 
                               1 
                             
                           
                           
                             
                               
                                 - 
                                 
                                   g 
                                   
                                     1 
                                     , 
                                     2 
                                   
                                   v 
                                 
                               
                               ⁢ 
                               
                                 I 
                                 mn 
                               
                             
                           
                           
                             
                                 
                             
                           
                         
                         
                           
                             
                               
                                 - 
                                 
                                   g 
                                   
                                     1 
                                     , 
                                     2 
                                   
                                   v 
                                 
                               
                               ⁢ 
                               
                                 I 
                                 mn 
                               
                             
                           
                           
                             
                               M 
                               2 
                             
                           
                           
                             
                               
                                 - 
                                 
                                   g 
                                   
                                     2 
                                     , 
                                     3 
                                   
                                   v 
                                 
                               
                               ⁢ 
                               
                                 I 
                                 mn 
                               
                             
                           
                         
                         
                           
                             
                                 
                             
                           
                           
                             
                               
                                 - 
                                 
                                   g 
                                   
                                     2 
                                     , 
                                     3 
                                   
                                   v 
                                 
                               
                               ⁢ 
                               
                                 I 
                                 mn 
                               
                             
                           
                           
                             
                               M 
                               3 
                             
                           
                         
                         
                           
                             
                                 
                             
                           
                           
                             
                                 
                             
                           
                           
                             
                                 
                             
                           
                         
                       
                       ] 
                     
                   
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   where 
                 
               
               
                 
                   ( 
                   42 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       M 
                       1 
                     
                     = 
                     
                       diag 
                       ⁡ 
                       
                         ( 
                         
                           
                             T 
                             1 
                           
                           , 
                           
                             T 
                             1 
                           
                           , 
                           
                             T 
                             1 
                           
                         
                         ) 
                       
                     
                   
                   , 
                   
                     
                       M 
                       3 
                     
                     = 
                     
                       diag 
                       ⁡ 
                       
                         ( 
                         
                           
                             T 
                             3 
                           
                           , 
                           
                             T 
                             3 
                           
                           , 
                           
                             T 
                             3 
                           
                         
                         ) 
                       
                     
                   
                 
               
               
                 
                   ( 
                   43 
                   ) 
                 
               
             
             
               
                 
                   
                     M 
                     2 
                   
                   = 
                   
                     [ 
                     
                       
                         
                           
                             
                               ( 
                               
                                 
                                   g 
                                   2 
                                 
                                 + 
                                 
                                   g 
                                   
                                     1 
                                     , 
                                     2 
                                   
                                   v 
                                 
                                 + 
                                 
                                   g 
                                   
                                     2 
                                     , 
                                     3 
                                   
                                   v 
                                 
                                 + 
                                 
                                   
                                     c 
                                     2 
                                   
                                   
                                     h 
                                     k 
                                   
                                 
                               
                               ) 
                             
                             ⁢ 
                             
                               I 
                               n 
                             
                           
                         
                         
                           
                             
                               - 
                               
                                 g 
                                 2 
                               
                             
                             ⁢ 
                             
                               I 
                               n 
                             
                           
                         
                         
                           
                               
                           
                         
                       
                       
                         
                           
                             
                               - 
                               
                                 g 
                                 2 
                               
                             
                             ⁢ 
                             
                               I 
                               n 
                             
                           
                         
                         
                           
                             
                               ( 
                               
                                 
                                   2 
                                   ⁢ 
                                   
                                     g 
                                     2 
                                   
                                 
                                 + 
                                 
                                   g 
                                   
                                     1 
                                     , 
                                     2 
                                   
                                   v 
                                 
                                 + 
                                 
                                   g 
                                   
                                     2 
                                     , 
                                     3 
                                   
                                   v 
                                 
                                 + 
                                 
                                   
                                     c 
                                     2 
                                   
                                   
                                     h 
                                     k 
                                   
                                 
                               
                               ) 
                             
                             ⁢ 
                             
                               I 
                               n 
                             
                           
                         
                         
                           
                             
                               - 
                               
                                 g 
                                 2 
                               
                             
                             ⁢ 
                             
                               I 
                               n 
                             
                           
                         
                       
                       
                         
                           
                               
                           
                         
                         
                           
                             
                               - 
                               
                                 g 
                                 2 
                               
                             
                             ⁢ 
                             
                               I 
                               n 
                             
                           
                         
                         
                           
                             
                               ( 
                               
                                 
                                   g 
                                   2 
                                 
                                 + 
                                 
                                   g 
                                   
                                     1 
                                     , 
                                     2 
                                   
                                   v 
                                 
                                 + 
                                 
                                   g 
                                   
                                     2 
                                     , 
                                     3 
                                   
                                   v 
                                 
                                 + 
                                 
                                   
                                     c 
                                     2 
                                   
                                   
                                     h 
                                     k 
                                   
                                 
                               
                               ) 
                             
                             ⁢ 
                             
                               I 
                               n 
                             
                           
                         
                       
                     
                     ] 
                   
                 
               
               
                 
                   ( 
                   44 
                   ) 
                 
               
             
             
               
                 
                   
                     T 
                     1 
                   
                   = 
                   
                     [ 
                     
                       
                         
                           
                             
                               g 
                               1 
                             
                             + 
                             
                               g 
                               
                                 1 
                                 , 
                                 2 
                               
                               v 
                             
                             + 
                             
                               
                                 c 
                                 1 
                               
                               
                                 h 
                                 k 
                               
                             
                           
                         
                         
                           
                             - 
                             
                               g 
                               1 
                             
                           
                         
                         
                           
                               
                           
                         
                       
                       
                         
                           
                             - 
                             
                               g 
                               1 
                             
                           
                         
                         
                           
                             
                               2 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               
                                 g 
                                 1 
                               
                             
                             + 
                             
                               g 
                               
                                 1 
                                 , 
                                 2 
                               
                               v 
                             
                             + 
                             
                               
                                 c 
                                 1 
                               
                               
                                 h 
                                 k 
                               
                             
                           
                         
                         
                           
                             - 
                             
                               g 
                               1 
                             
                           
                         
                       
                       
                         
                           
                               
                           
                         
                         
                           
                             - 
                             
                               g 
                               1 
                             
                           
                         
                         
                           
                             
                               g 
                               1 
                             
                             + 
                             
                               g 
                               
                                 1 
                                 , 
                                 2 
                               
                               v 
                             
                             + 
                             
                               
                                 c 
                                 1 
                               
                               
                                 h 
                                 k 
                               
                             
                           
                         
                       
                     
                     ] 
                   
                 
               
               
                 
                   ( 
                   45 
                   ) 
                 
               
             
             
               
                 
                   
                     T 
                     3 
                   
                   = 
                   
                     [ 
                     
                       
                         
                           
                             
                               g 
                               3 
                             
                             + 
                             
                               g 
                               
                                 2 
                                 , 
                                 3 
                               
                               v 
                             
                             + 
                             
                               g 
                               p 
                             
                             + 
                             
                               
                                 c 
                                 3 
                               
                               
                                 h 
                                 k 
                               
                             
                           
                         
                         
                           
                             - 
                             
                               g 
                               3 
                             
                           
                         
                         
                           
                               
                           
                         
                       
                       
                         
                           
                             - 
                             
                               g 
                               3 
                             
                           
                         
                         
                           
                             
                               2 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               
                                 g 
                                 3 
                               
                             
                             + 
                             
                               g 
                               
                                 2 
                                 , 
                                 3 
                               
                               v 
                             
                             + 
                             
                               
                                 c 
                                 3 
                               
                               
                                 h 
                                 k 
                               
                             
                           
                         
                         
                           
                             - 
                             
                               g 
                               3 
                             
                           
                         
                       
                       
                         
                           
                               
                           
                         
                         
                           
                             - 
                             
                               g 
                               3 
                             
                           
                         
                         
                           
                             
                               g 
                               3 
                             
                             + 
                             
                               g 
                               
                                 2 
                                 , 
                                 3 
                               
                               v 
                             
                             + 
                             
                               
                                 c 
                                 3 
                               
                               
                                 h 
                                 k 
                               
                             
                           
                         
                       
                     
                     ] 
                   
                 
               
               
                 
                   ( 
                   46 
                   ) 
                 
               
             
           
         
       
     
     In the above, g i  and c i  denote the average branch conductance and the average node capacitance in the i-th metal layer. Also h k  is the current analysis time-step (possibly variable), g i,j+1   v  is the average via conductance connecting the i-th and (i+1)-th metal layers, and 
               g   p     ≡     1       r   p     +       l   p       h   k                 
is the parasitic conductance of the supply pads.
 
     We observe that the form of the above matrix is almost identical to (21), with the exception of the pad parasitic conductance g p  in few places along the diagonal of the M 3  block that corresponds to the uppermost metal layer. In order to obtain a preconditioner M with an exact form that can be efficiently solved by a 3D Fast Transform solver, we can just omit entirely those pad parasitics. However, we have observed that in practice it is usually better to amortize the total sum of pad conductances of the uppermost metal layer (in the regular 3D grid) to all nodes of this layer, i.e. assume that all nodes of the uppermost layer have pad conductance 
                   g   _     p     =       ∑     g   p         n   ⁢           ⁢   m         ,         
where Σg p  is the sum of the actual pad conductances attached to nodes of the uppermost layer. This also has the beneficial effect of making the preconditioner M non-singular in the case of DC analysis (where capacitances are absent). In the above example, the blocks T 3  of M 3  would become:
 
                     T   3     =               [             g   3     +     g     2   ,   3     v     +       g   _     p     +       c   3       h   k               -     g   3                             -     g   3               2   ⁢           ⁢     g   3       +     g     2   ,   3     v     +       g   _     p     +       c   3       h   k               -     g   3                             -     g   3               g   3     +     g     2   ,   3     v     +       g   _     p     +       c   3       h   k               ]     ⁢     
     ⁢           ⁢   where   ⁢           ⁢       g   _     p       =         g   p     9     .                 (   47   )               
It is not difficult to generalize the procedure to an arbitrary power grid with m horizontal rails, n vertical rails and l layers. In that case, the preconditioner will comprise l blocks of size mn×mn and have the form (21), where
 
     
       
         
           
             
               
                 α 
                 i 
               
               = 
               
                 g 
                 i 
               
             
             , 
             
               ( 
               
                 
                   i 
                   = 
                   1 
                 
                 , 
                 … 
                 ⁢ 
                 
                     
                 
                 , 
                 l 
               
               ) 
             
             , 
             
               
 
             
             ⁢ 
             
               
                 β 
                 i 
               
               = 
               
                 
                   g 
                   
                     
                       i 
                       - 
                       1 
                     
                     , 
                     i 
                   
                   v 
                 
                 + 
                 
                   g 
                   
                     i 
                     , 
                     
                       i 
                       + 
                       1 
                     
                   
                   v 
                 
                 + 
                 
                   
                     c 
                     i 
                   
                   
                     h 
                     k 
                   
                 
               
             
             , 
             
               ( 
               
                 
                   i 
                   = 
                   1 
                 
                 , 
                 … 
                 ⁢ 
                 
                     
                 
                 , 
                 
                   l 
                   - 
                   1 
                 
                 , 
                 
                   
                     with 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     
                       g 
                       
                         0 
                         , 
                         1 
                       
                       v 
                     
                   
                   = 
                   0 
                 
               
               ) 
             
             , 
             
               
 
             
             ⁢ 
             
               
                 β 
                 l 
               
               = 
               
                 
                   g 
                   
                     
                       l 
                       - 
                       1 
                     
                     , 
                     l 
                   
                   v 
                 
                 + 
                 
                   
                     g 
                     _ 
                   
                   p 
                 
                 + 
                 
                   
                     c 
                     l 
                   
                   
                     h 
                     k 
                   
                 
               
             
             , 
             
               
                 and 
                 ⁢ 
                 
                     
                 
                 ⁢ 
                 
                   γ 
                   i 
                 
               
               = 
               
                 
                   
                     g 
                     
                       i 
                       , 
                       
                         i 
                         + 
                         1 
                       
                     
                     v 
                   
                   ⁡ 
                   
                     ( 
                     
                       
                         i 
                         = 
                         1 
                       
                       , 
                       … 
                       ⁢ 
                       
                           
                       
                       , 
                       
                         l 
                         - 
                         1 
                       
                     
                     ) 
                   
                 
                 . 
               
             
           
         
       
     
     Advantages for 3D Networks: 
     Compared to the preconditioning mechanisms presented in Zhao et al. and Yang et al. (both cited above), the proposed preconditioner offers significant advantages, similar to those described under “Advantages for 2D networks” above. Compared with the preconditioner presented in Zhao et al. that has a complexity of O(N 1.5 ), our invention reduces the required complexity to O(N)+O(N(log n+log m))=O(N log(nm)) operations and is amenable to massive parallelism. 
     Procedure Implementation and Opportunities for Parallelism: 
     After the preconditioner construction and storage, the whole procedure involves execution of Algorithm 1 with Algorithm 2 for 2D or Algorithm 3 for 3D power delivery network designs, in place of the preconditioner solve step Mz=r. The proposed overall procedure for transient analysis of power delivery networks is depicted in Algorithm 6 below. Every part of this procedure offers ample multi-grain parallelism, both data- and task-level, thus enabling highly parallel computing efficiency. This comes in contrast with most standard preconditioning methods, such as incomplete factorizations, which have limited parallelism, either data-level or task-level. The details for each major part of the procedure, as well as the opportunities for introducing parallelism are presented below. 
     Algorithm 6 for 2D Networks. 
     With reference to  FIG. 5 , the preferred algorithm for power grid transient analysis  500  includes the following steps ( 501 ,  505 ,  510 ,  515 ,  520 ,  525 ,  530 ,  535 ,  540 ,  545 ,  550 ,  555 ,  560 ,  565  and  570 ):
         1. Parse netlist data  505     2. Create circuit matrix and preconditioner matrix  510 ,  515  with Algorithm 4 (described above and depicted in  FIG. 9  with steps referenced as  5101 ,  5105 ,  5110 ,  5115 ,  5120 ,  5125  and  5130 )   3. for all time-steps do   4. If time-step has changed   5. Reconstruct preconditioner  515  (update preconditioner&#39;s eigenvalues)   6. end if   7. Solve linear system from eq. (9) using PCG (Algorithm 1,  520  through  565  in  FIG. 5 ) employing Algorithm 2 ( 550 ) (described above and depicted in  FIG. 7  with steps referenced as  5501 ,  5510 ,  5515 ,  5520 ,  5525 ,  5530  and  5535 ).   8. end for       

     Algorithm 6 for 3D Networks. 
     With reference to  FIG. 6 , the preferred algorithm for power grid transient analysis  600  includes the following steps ( 601 ,  605 ,  610 ,  615 ,  620 ,  626 ,  630 ,  635 ,  640 ,  645 ,  650 ,  655 ,  660 ,  665  and  670 ):
         1. Parse netlist data  605     2. Create circuit matrix and preconditioner matrix  610 ,  615  with Algorithm 5 (described above and depicted in  FIG. 10  with steps referenced as  6101 ,  6105 ,  6110 ,  6115 ,  6120  and  6125 )   3. for all time-steps do   4. If time-step has changed   5. Reconstruct preconditioner  615  (update preconditioner&#39;s eigenvalues)   6. end if   7. Solve linear system from eq. (9) using PCG (Algorithm 1,  520  through  565  in  FIG. 5 ) employing Algorithm 3 ( 650 ) (described above and depicted in  FIG. 8  with steps referenced as  6501 ,  6510 ,  6515 ,  6520 ,  6525 ,  6530 ,  6535 ,  6540 ,  6545 ,  6550  and  6555 .)   8. end for       

     As seen in Algorithm 1, apart from the preconditioner solve step, the PCG method involves 2 inner products and 1 sparse matrix-vector product per iteration, which can be implemented efficiently by available BLAS-1 and BLAS-2 (Basic Linear Algebra Subroutines) kernels. The algorithm also has 3 scalar-vector products with vector updates per iteration which can be fully parallelized. 
     In addition, in order to apply the independent DCT-II and IDCT-II transforms in Algorithm 2 ( 5510  and  5530  in  FIG. 7 ) and Algorithm 3 ( 6510 ,  6520 ,  6540  and  6550  in  FIG. 8 ), we can use a modification of the one-dimensional Fast Fourier Transform (FFT) algorithm (as described in C. Van Loan, “ Computational Frameworks for the Fast Fourier Transform ”, SIAM, 1992, which is incorporated herein by reference in its entirety), which gives a near-optimal sequential complexity of O(n log n) operations for each transform of size n. FFT is also a highly parallel algorithm and an ideal candidate for mapping onto a parallel computing architecture, with a parallel complexity of O((n log n)/p), where p is the number of available processors. 
     The solution of tridiagonal systems in Algorithm 2 ( 5520  in  FIG. 7 ) and Algorithm 3 ( 6530  in  FIG. 8 ), offers abundant data-level parallelism as well, and various algorithms have been proposed in the literature for its implementation on parallel architectures. These can be classified to algorithms that target coarse-grain parallelism (and are appropriate for multi-core processors) such as two-way Gaussian elimination or Bondelli&#39;s algorithm (as described in paper P. Quesada-Barriuso, J. Lamas-Rodriguez, D. B. Heras, M. Bóol, and F. Argüello, “Selecting the Best Tridiagonal System Solver Projected on Multi-Core CPU and GPU Platforms”,  Int. Conf. on Parallel and Distributed Processing Techniques and Applications  ( as part of WorldComp 2011  Conference ), which is incorporated herein by reference in its entirety) and to algorithms that exploit fine-grain parallelism (and are appropriate for GPUs) such as Parallel Cyclic Reduction (as described in paper Y. Zhang, J. Cohen, and J. D. Owens, “Fast Tridiagonal Solvers on the GPU”,  ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming,  2010, which is incorporated herein by reference in its entirety). 
     Moreover, Algorithm 2 and Algorithm 3 entail a number of DCT-II and IDCT-II transforms as well the solution of a series of tridiagonal systems, operating on sparse preconditioner matrices as depicted in  FIG. 11  for 2D networks and  FIG. 12  for 3D networks. In these figures, dots graphically represent the non-zero elements of the matrices. The preconditioner matrix form in  FIG. 11  comprises off-diagonal blocks which are diagonal matrices and main diagonal blocks which are tridiagonal matrices; the preconditioner matrix form in FIG.  12  comprises off-diagonal blocks which are diagonal matrices and main diagonal blocks which are either tridiagonal or block diagonal matrices. As described above under “Algorithm 2” and “Algorithm 3”, these solution steps can be broken down in smaller size partitions which may be processed independently of each other. This translates to additional task-level parallelism, which can lead to further acceleration of the whole preconditioner solve step on parallel computing architectures, where all independent transforms and tridiagonal solvers can be executed in parallel processes, requiring only a small amount of inter-process communication. 
     The present invention may be conveniently implemented using one or more conventional general purpose or specialized digital computer, computing device, machine, or microprocessor, including one or more processors, memory and/or computer readable storage media programmed according to the teachings of the present disclosure. In some embodiments, the one or more processors can be, for example, a general purpose graphics processing unit (GPU) commonly used as a modified form of stream processor. In other embodiment, the one or more processors can be, for example, a networked computer cluster. Appropriate software coding can readily be prepared by skilled programmers based on the teachings of the present disclosure, as will be apparent to those skilled in the software art. 
     In some embodiments, the present invention includes a computer program product which is a storage medium or computer readable medium (media) having instructions stored thereon/in which can be used to program a computer to perform any of the processes of the present invention. The storage medium can include, but is not limited to, any type of disk including floppy disks, optical discs, DVD, CD-ROMs, microdrive, and magneto-optical disks, ROMs, RAMs, EPROMs, EEPROMs, DRAMs, VRAMs, flash memory devices, magnetic or optical cards, nanosystems (including molecular memory ICs), or any type of media or device suitable for storing instructions and/or data. 
     The previous description of the preferred embodiments is provided to enable any person skilled in the art to make or use the embodiments of the present invention. While the invention has been particularly shown and described with reference to preferred embodiments thereof, it will be understood by those skilled in the art that various changes in form and details may be made therein without departing from the spirit and scope of the invention.