Abstract:
A new method of searching paths that are suffering ESD is proposed in this invention, improving the design flow of a VLSI circuit and reducing the cost of designing the ESD circuits in a whole chip, comprising three parts, the circuit flattening, the closure algorithm, and the supernode algorithm. The objective is to find the paths satisfying the following two constraints: (1) only one edge connected to the gate pin and the source (or drain) pin is allowed; (2) only the head-node and the tail-node in a path could be the pin of top-level circuit. Two algorithms in this invention are the closure algorithm that uses the closure property in the −1/0/1 matrix multiplication so that the connective property of nodes can be observed after several matrix self-multiplication, and the supernode algorithm.

Description:
BACKGROUND OF THE INVENTION 
       [0001]    1. Field of the Invention 
         [0002]    This invention relates to a method of searching paths that are suffering from the electrostatic discharge in the process of an integrated circuit design and particularly to a method for a designer beforehand searching paths that is suffering from the electrostatic discharge in a field of an integrated circuit design, for the purpose of time saving, power saving, and protection to VLSI. 
         [0003]    2. Description of Related Art 
         [0004]    In the course of manufacturing, assembly and packaging, and delivery of electronic products and even at the time of use of electronic products after purchased by users, there is pretty high probability of harm from electrostatic discharge (ESD), so a technology of ESD guard is a must to provide in all electronic products. Especially when a deep submicron system-on-a-chip (SoC) employed in the process of advanced semiconductor manufacturing suffers from ESD, the inter components of SoC may be damaged by electrostatic current and even the current make the whole SoC fail, so the SoC must be provided with a better ESD guard circuit to withstand a higher degree of ESD. 
         [0005]    For security of the whole circuit, the technology of ESD guard circuit is essential in the current chip industry, and 8 principles are below concluded in the technology.
       1. Avoid decisive signal lines tracing near protected lines;   2. arrange interfaces together at one side as far as possible;   3. avoid protected loops connecting in parallel to loops that are not protected;   4. an area around a loop formed with various signal lines and their feeders should be small as far as possible, and consider to change the position of signal lines or ground wires, if necessary;   5. keep the signals of homing, interrupt, and control far from I/O ports and the edges of a PCB;   6. connect interface signal lines and ground wires to a guard component and then to other parts of the loop;   7. make use of high integrated components and a diode array that may not only greatly economize the use of the space of a circuit board but also lower the self inductance of a sneak circuit that is caused by a complicated loop; and   8. add ground points, if possible.       
 
         [0014]    Of the 8 items, items 1 through 5 are much more known to a circuit designer. However, even if the five items are fully observed, they cannot completely prevent the components in the SoC from suffering from ESD. The five items at most reduce the probability of ESD, so a blind spot exists. Items 6 through 7 are diverse, popular items in the current technology of ESD guard, and parallel connection is made to hardware components protected by a circuit, in which many options are given for the protected components, such as U.S. Pat. No. 6,906,357, U.S. Pat. No. 6,894,881, U.S. Pat. No. 6,730,968, and U.S. Pat. No. 6,274,911. Generally, in a guard IC, a diode is frequently used because the diode may be easily integrated with other components in a chip; for example, there are currently components provided with the functions of electromagnetic interference (EMI) and radio frequency interference (RFI) guard being integrated with the diodes, which not only reduce the amount of components employed in design for cost down but also prevent associated self-inductance easily caused at the time of layout of wires on the PCB; especially, a transient voltage suppression (TVS) diode is nowadays a major guard component against ESD caused in the integrated circuit. Compared with a conventional Zener diode (ZD), it is capable of withstand higher voltage, is provided with a lower voltage cut-off ratio, and thus provides a better effect on voltage loop protection for security. 
         [0015]    Consequently, because of the technical defects of described above, the applicant keeps on carving unflaggingly through wholehearted experience and research to develop the present invention, which can effectively improve the defects described above. 
       SUMMARY OF THE INVENTION 
       [0016]    A technical problem to be solved in this invention is described below. 
         [0017]    The conventional art described above mostly tends toward an ESD guard circuit design and collocation of ESD guard components. Although it may prevent a circuit from suffering from ESD, current a VLSI circuit comprises millions of logic gates and thousands of pins. The VLSI circuit completely avoiding ESD, an antistatic circuit must be provided at each pin, but the cost is extremely high. 
         [0018]    A solution to the above problem is given below. 
         [0019]    Here, this invention provides a method of searching paths that are suffering from the electrostatic discharge in the process of an integrated circuit design, comprising the steps of: 
         [0020]    Input a netlist of the integrated circuit to a computer system; 
         [0021]    flattening the netlist of integrated circuit; 
         [0022]    searching paths in the integrated circuit that are suffering from the electrostatic discharge in an Matrix closure algorithm; and 
         [0023]    outputting the paths that are suffering from the electrostatic discharge. 
         [0024]    Advantageously, the paths that are suffering from the electrostatic discharge may be defined to: 
         [0025]    connection from MOS&#39;s Gate to Source (Drain) pin only in the path; and 
         [0026]    only head and tail nodes that may serve as I/O pin nodes in the path. 
         [0027]    The matrix closure algorithm comprises the steps of: 
         [0028]    building up a −1/0/1 sparse matrix A according to the relationship of connection of nodes in the circuit; 
         [0029]    multiplying matrices, and setting a matrix element to 0 when the connection acts against a path limitation; 
         [0030]    connecting other nodes after n times of multiplication for n connections of nodes, and then searching a target path; and 
         [0031]    terminating the multiplication of matrices when the matrices are multiplied and no variation happens, namely A n =A n−1 ×A. 
         [0032]    Further, this invention also provides another method of searching paths that are suffering from the electrostatic discharge in the process of an integrated circuit design, comprising the steps of: 
         [0033]    Input a netlist of the integrated circuit to a computer system; 
         [0034]    flattening the netlist of integrated circuit; 
         [0035]    searching paths in the integrated circuit that are suffering from the electrostatic discharge in a super-node algorithm; and 
         [0036]    outputting the paths that are suffering from the electrostatic discharge. 
         [0037]    The paths that are suffering from the electrostatic discharge may be defined to: 
         [0038]    connection from MOS&#39;s Gate to Source (Drain) pin only in the path; and 
         [0039]    only head and tail nodes that may serve as I/O pin nodes in the path. 
         [0040]    The supernode algorithm comprises the steps of: 
         [0041]    selecting a node provided with the feature of Gate, which serves as a seed expanding supernode; 
         [0042]    merging into the supernode a node equivalent in status to the seed node, such as an adjacent node passing through a passive element and a node passing through a transistor&#39;s Source (Drain); 
         [0043]    determining the extent of expansion of the supernode by a user; 
         [0044]    making only the supernode and its connection when the step of expanding the supernode in the circuit ends, in which the connection is provided with the feature of Gate of the transistor to Source (Drain); and 
         [0045]    providing two ways of searching the target paths, one between the pins in the supernode and the other between the pins located between the supernodes, in which the target paths must satisfy the restrictions. 
         [0046]    Virtues collocated with those of the prior arts: 
         [0047]    This invention provides a mechanism of searching paths in advance that are suffering from the electrostatic discharge in the process of an integrated circuit design. In the method of this invention, a suite of computer-aided simulation software that searches the paths in the integrated circuit that are suffering from ESD may be designed, thereby being provided with advantages of time saving, power saving, and protection to the VLSI circuit for the integrated circuit design. 
         [0048]    However, in the description mentioned above, only the preferred embodiments according to this invention are provided without limit to this invention and the characteristics of this invention; all those skilled in the art without exception should include the equivalent changes and modifications as falling within the true scope and spirit of the present invention. 
     
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0049]      FIG. 1  is a complete flow chart of this invention; 
           [0050]      FIG. 2  is a flow chart illustrating a circuit flattening process of this invention that is described at step  2  of  FIG. 1 ; 
           [0051]      FIG. 3  is a schematic internal flow chart illustrating a depth search algorithm of this invention that is described at step  24  of  FIG. 2 ; 
           [0052]      FIG. 4  is a schematic view illustrating the structure of a closure matrix according to this invention; 
           [0053]      FIG. 5  is a schematic internal flow chart illustrating an matrix closure algorithm of this invention that is described at step  30  of  FIG. 1 ; and 
           [0054]      FIG. 6  is a schematic internal flow chart illustrating a supernode algorithm of this invention that is described at step  31  of  FIG. 1 . 
       
    
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS 
       [0055]    Now, the present invention will be described more specifically with reference to the following embodiments. It is to be noted that the following descriptions of preferred embodiments of this invention are presented herein for purpose of illustration and description only; it is not intended to be exhaustive or to be limited to the precise form disclosed. 
         [0056]    This invention relates to a method of searching paths that are suffering from the electrostatic discharge in the process of an integrated circuit design. As shown in  FIG. 1 , this invention is analysis on paths in a circuit that are suffering from electrostatic discharge, comprising: 
         [0057]    step  1  for a netlist: 
         [0058]    netlist data of an integrated circuit comprising resistors, inductors, capacitors, conductors, diodes and the like as passive elements, and metal-oxide semiconductor (MOS) as active elements is inputted to a computer system; 
         [0059]    step  2  for a flattening process: 
         [0060]    the inputted netlist data is flattened; 
         [0061]    step  3  for algorithms: 
         [0062]    for a flattened circuit, this invention provides two algorithms of searching paths suffering from ESD, comprising an matrix closure algorithm and a supernode algorithm shown in  FIG. 1 , in which 
         [0063]    at step  30  for the matrix closure algorithm, a −1/0/1 matrix is formed by the relationship of connection of nodes and a target path may be given after sequent matrices are multiplied; and 
         [0064]    at step  31  for the supernode algorithm, supernodes are expanded to reduce the amount of nodes, thereby reducing the complexity of search for the paths suffering from ESD and reducing the quantity of a memory use, in which 
         [0065]    in the two algorithms, all of the paths suffering from ESD may be fast found, in which the pin paths passing from Gate to Source (Drain) and from Source to Drain; and 
         [0066]    step  4  for output paths: 
         [0067]    the paths suffering from ESD that are analyzed at the steps are outputted from the computer system. 
         [0068]    Next, to reduce the loss of time spent by the program to run, this invention in advance provides a detailed data structure to simplify the operation, such as sub-circuit information, node information, and child node information. Then, the detailed structure of a test circuit may be quickly recorded. Due to huge quantity of node data, a hash skill is used to store nodes, and a linked-list data structure is combined to store the front and back stages of all the elements in a database for the node, which is quite helpful to convert and calculate the circuit structure. The steps in the algorithms according to this invention are in detail described below. 
         [0069]    (1) “Circuit Flattening Process” at step  2   
         [0070]    In the process of current circuit design, generally, a hierarchical circuit structure is used to complete the design of VLSI circuit. In this invention, the technology of circuit flattening is applied, in which the hierarchically structured circuit is analyzed in two ways of Top-Down or Bottom-Up. In the algorithm that converts the hierarchical circuit into the flattened circuit, according to sub-circuit information, X for the symbol, in a topmost layer of circuit, a method of Depth First Search (DFS) is used to read the nodes of sub-circuit in the data structure. In order to prevent a read-in information error caused by a multiple applied single sub-circuit in the circuit, the program connect in series the sub-circuit node name to the topmost circuit name; finally, a flattened circuit fully corresponding to the original circuit may be given. 
         [0071]    The algorithm is to flatten the netlist data circuit comprising resistors, inductors, capacitors, conductors, diodes and the like as passive elements, and metal-oxide semiconductor (MOS) as active elements.  FIG. 2  is a flow chart illustrating in detail a circuit flattening process of this invention that is described at step  2  of  FIG. 1 . As shown in  FIG. 2 , after the netlist data (step  1 ) is inputted, at step  21 , search for a sub-circuit of each node in a circuit from the topmost layer of circuit starts; at step  22 , the node data in the topmost layer of circuit is stored in the data structure; and at step  23 , the read-in data structure that exists or not in the sub-circuit not recognized is determined, and if not, step  25  is executed to stop the algorithm, and if yes, through step  24 , a recursive algorithm for depth first search is executed to search all nodes in the bottom layer of circuit and then input them to the data structure, and after completion, return to step  24  determines whether any sub-circuit not processed exists. 
         [0072]      FIG. 3  is a schematic internal flow chart illustrating a depth search algorithm that is described at step  24  of  FIG. 2 , in which 
         [0073]    at step  241 , each node information in the sub-circuit is inputted to the data structure one after another, and to prevent repetition of node names in the circuit, this invention connect in series the node names of sub-circuit to the name of the top layer of circuit; 
         [0074]    at step  242 , determination is made whether any sub-circuit is not analyzed; if a sub-circuit is not analyzed, then the recursive algorithm for depth first search described at step  243  is executed until completion of the analysis on all sub-circuits; finally, the recursive algorithm for depth first search ends at step  244  and step  24  described in  FIG. 2  returns. 
         [0075]    In the recursive algorithm for depth first search, the hierarchical circuit of original circuit may be converted into the flattened circuit structure for follow-up algorithms. 
         [0076]    (2) “Matrix Closure Algorithm” at step  30   
         [0077]    To show a circuit structure, an array may be used to indicate the relationship of nodes in the circuit. In this invention, the matrix closure algorithm is used to investigate the relationship of nodes. In the matrix closure algorithm, an array A is defined to the relationship of all the nodes, and the structure of array is directional. After multiplication of matrices A n =A*A n−1  several times, all pieces of node information on interconnected paths may be found. 
         [0078]    By the above definition, this invention search a target path using the feature of −1/0/1 array multiplication closure. At first, numbers are assigned to all the nodes in the circuit, and a −1/0/1 array is structured for the relationship of nodes. If a node passes through Gate of a transistor, the location number is −1; if it passes through two terminals of a passive element or Source and Drain of the transistor, the location number is 1 and the rest are 0. From the above definition, the matrix A is formed from a simple circuit shown in  FIG. 4 , and after the matrices are multiplied once, an array A 2  as shown in  FIG. 4  may be given, in which A 2 (Q,S)=A(Q,R)×A(R,S)=−1 is a condition satisfying the path leading to Gate one time, while A 2 (P,T)=A(P,R)×A(R,T)=0 is set to 0 because the path leads to Gate two times; the algorithm provided in this invention is in detail described in steps. 
         [0079]    After the whole circuit is flattened at step  2 , the array closure algorithm at step  30  may be applied.  FIG. 5  is an internal block diagram showing the array closure algorithm of this invention that is described at step  30  of  FIG. 1 , in which step  300  starts for the matrix closure algorithm, and an input herein is a circuit flattened; 
         [0080]    at step  301 , numbers are assigned to all the pins and nodes for identification of the properties of nodes and construction and operation of the array; 
         [0081]    at step  302 , the −1/0/1 sparse matrix A is structured to indicate the relationship of nodes; if the node passes through Gate of the transistor, the location number is −1; if it passes through the two terminals of passive element or Source and Drain of the transistor, the location number is 1 and the rest are 0; 
         [0082]    at step  303 , the matrices A n =A×A n−1  are multiplied, in which n is a number of times for multiplication of matrices, and the matrices after operated are still −1/0/1 matrices, and the operation is briefly described below; assumed that the node numbers are i, j, and k, (1) when A n−1 (i,k)=−1 and A n−1 (k,j)=−1 and A n−1 (i,k)=0 and A n−1 (k,j)=0 then A n (i,j)=0; (2) when A n−1 (i,k)=0 and A n−1 (k,j)=−1 and A n−1 (i,k)=−1 and A n−1 (k,j)=1, then A n (i,j)=−1; and (3) when A n−1 (i,k)=0 and A n−1 (k,j)=1 and A n−1 (i,k)=1 and A n−1 (k,j)=1, then A n (i,j)=1; 
         [0083]    at step  304 , determination is made whether the paths exist between the pins and whether the target paths exists after the closure matrix multiplication; if it does not, then the step returns to step  303  for a further closure matrix multiplication process, and if the nodes I and j are I/O pins of the topmost layer of circuit and A n (i,j)=1 or A n (i,j)=−1, then target paths may be given; 
         [0084]    at step  305 , the paths are recorded in the data structure of computer system except the path given 0 from, since the principle of passing through a Gate is disobeyed, as shown in  FIG. 4  for A 2 (P,S)=0 and A 2 (P,T)=0 in the matrix A 2 ; 
         [0085]    at step  306 , a relative element of the matrix is set to 0; after the paths are recorded at step  305 , A n (i,j)=0 is set to satisfy the requirement of only head and tail nodes that may serve as pins in the paths suffering from ESD; after the array closure operation is executed, the relationship of nodes deepens; 
         [0086]    at step  307 , determination is made whether A n =A×A n−1  comes into existence or not; if it does, search for the paths is completed, step  308  enters, the step ends, and a result given from the path search is outputted; if it does not, next multiplication of matrices may be processed and new paths are again searched at step  304 . 
         [0087]    In the current design of integrated circuit, a node generally links to a neighboring node and thus an element of a matrix is 0. Thus, a dense matrix is applied for operation, a memory is abused so as to make the algorithm slow, and a larger memory space is required to construct a matrix. As a result, the sparse matrix is further employed in this invention to effectively reduce the complexity of algorithm. The sparse matrix memorizes a value and its address (X, Y, and Value) only, so the quantity of a memory in use may be saved. Further, the memory for the product of sparse matrices is occupied less than that for dense matrices, and the phenomenon is remarkable all the better with the increase of matrices in scale. 
         [0088]    (3) “Supernode Algorithm” at step  31   
         [0089]    When the netlist is flattened, around ten thousands of nodes are generally provided in the current large circuit. To reduce the complexity of algorithm, the concept of supernode is applied in this invention, the nodes equivalent in status being grouped together. To expand and limit the supernodes is a stress in this algorithm.  FIG. 6  is an internal block diagram of the supernode algorithm of this invention that is described at step  31  of  FIG. 1 , in which 
         [0090]    at step  310 , “the supernode algorithm” is executed; 
         [0091]    at step  311 , “selecting a node” is setting in order the nodes in the circuit that are not processed to the seed nodes of the supernodes from which the supernodes is expanded; 
         [0092]    at step  312 , determination is made whether all the nodes are processed or not; if they are, step  313  enters and the step ends and outputs the paths; in this invention, the nodes (Gate of the transistor) in the circuit that are featured with the seed nodes are arranged and processed in the order; after the seed nodes are operated, the step of this invention stops and outputs the paths; 
         [0093]    If there are other nodes, then step  314  enters to construct the supernodes from the original circuit, a node featured with a gate pin may be selected from the circuit to serves as a seed node, the nodes interconnected, namely a source node and a drain node of the same transistor, are grouped into a supernode, and a node in the supernode is absorbed with a node equivalent in status into the supernode in a breadth first search (BFS) algorithm, such as the nodes at two terminals of a resistor and those of a diode, in which the same status indicates that the connection does not pass through Gate of the transistor; besides, excessively expanded supernodes make the algorithm of searching for the paths in the supernodes more complicated; thus, a heuristic method is provided in this invention for a user to determine the extent of expansion by himself or herself; 
         [0094]    at step  315 , information on pins in the supernodes is extracted, indicating that the nodes featured with pins are extracted from the supernodes; after the circuit net is simplified, edges between the supernodes are featured with Gate to Source (Drain) so that the path is divided into two parts by determination, one for a pin pair in the supernode and the other for a pin pair between the supernodes that passes through an edge only; 
         [0095]    at step  316 , determination is made whether all the pins are processed, namely whether the pin pair exists; if it does, step  317  enters to determine the paths and record them in the data structure, and if it does not, the step returns to step  311  to create a new supernode; according to this invention, in the process of determination of the paths, the target is the pin in the supernode; when pairs of pins exist in the supernode, the target path may exist; thus, the step does not jump out of the loop until the pin information is processed; and 
         [0096]    at step  317 , the paths are determined, which is similar to step  303  described above; when the existing paths satisfy conditions a. the path comprises only an edge from Gate to Source (Drain) and b. only head and tail nodes may serve as I/O pin nodes in the path, the paths suffering from ESD that is defined in this invention is established and the step must return to step  316  to determine whether all the pins are processed or not; thus, after the information is processed at step  316 , the step jump out of the loop. 
         [0097]    From the above description, there are three algorithms in this invention, the flattening algorithm, the array closure algorithm, and the supernode algorithm, respectively. The algorithms are respectively described below for analysis on their complexity. 
         [0098]    1. For a fundamental spirit, the flattening algorithm and the supernode algorithm are the depth search algorithm. The steps of flattening process starts from the topmost layer of circuit. If a sub-circuit exists, the sub-circuit is renamed and added to the topmost layer of the circuit; if the sub-circuit also exists in a sub-circuit, according to the above rule, the node is added to the node data structure of the topmost layer of circuit. The supernode algorithm may be regarded as a combination of the breadth first search algorithm and the depth first search algorithm. Determination of supernode construction is made in the one-time breadth first search algorithm, while the paths in the supernode network are searched in the one-time depth first search algorithm. In the depth first search algorithm, the analysis on a conventional complexity is O(V+E), in which V stands for an entry of network node and E stands for an entry of network connection. In Table 1 below, V and E in the algorithms are defined. Thus, this program may find target paths in a complicated circuit within a linear time in the above algorithms. 
         [0000]    
       
         
               
               
               
             
               
               
               
             
               
               
               
               
             
           
               
                   
                 TABLE 1 
               
               
                   
                   
               
               
                   
                 V 
                 E 
               
               
                   
                   
               
             
             
               
                   
               
             
          
           
               
                 Flattening Algorithm 
                 Number of nodes in a 
                 Number of edges in a 
               
               
                   
                 circuit 
                 circuit 
               
               
                 Depth First Search 
                 Number of nodes in a 
                 Number of edges in a 
               
               
                 Algorithm 
                 circuit 
                 circuit 
               
             
          
           
               
                 Supernode 
                 Construction 
                 Entries of nodes in 
                 Number of edges in 
               
               
                 Algorithm 
                   
                 supernodes 
                 supernodes 
               
               
                   
                 Network 
                 Entries of supernodes 
                 Number of edges 
               
               
                   
                   
                   
                 between supernodes 
               
               
                   
               
             
          
         
       
     
         [0099]    2. In the matrix closure algorithm, numbers are at first assigned to the nodes according to the relationship of nodes after flattened. If the total of nodes in the circuit is V, because the entries connecting to the nodes are far smaller than V and the hash structure is used for data storage and search, the complexity of algorithm in number assignment is about O(V). Next, the complexity of algorithm that is required for the matrix multiplication of matrix size as V is O(V 3 ), which takes much more time. This invention further uses the sparse array construction and execute the array multiplication, which is expected to greatly reduce the quantity of a memory in use and reduce the complexity to O(V 2 ). Thus, the algorithm complexity in the array closure algorithm is O(V 2 ). 
         [0100]    Again, three simple embodiments are used for test to verify the accuracy of algorithms proposed. In embodiment 1, there are 109 nodes and 17 pins; in embodiment 2, there are 11 nodes and 4 pins; in embodiment 3, there are 116 nodes and 17 pins; the inputted netlists are hierarchical circuit structure. As shown in Table 2, the nodes and pins in the three embodiments are arranged. The operation time and the quantity of memory usage that are required in the algorithms according to this invention are given in Table 2, in which the operation time is a real part given from the command “timex” in Sun workstation and the quantity of memory usage is SIZE for the command “top”. 
         [0000]    
       
         
               
               
             
               
               
               
               
             
               
               
               
               
             
               
               
               
               
               
             
           
               
                   
                 TABLE 2 
               
             
             
               
                   
                   
               
               
                   
                 Test Embodiments 
               
             
          
           
               
                   
                 Embodiment 1 
                 Embodiment 2 
                 Embodiment 3 
               
               
                   
                   
               
             
          
           
               
                 Total Supernodes 
                 109 
                 11 
                 116 
               
               
                 Total Pins 
                 17 
                 4 
                 17 
               
               
                 Flattening 
                 0.02 sec 
                 0.01 sec 
                 0.04 sec 
               
             
          
           
               
                 Supernode 
                 Total 
                 48 
                 4 
                 30 
               
               
                 Algorithm 
                 Paths 
               
               
                   
                 Time 
                 0.45 sec 
                 0.02 sec 
                 0.38 sec 
               
               
                   
                 Memory 
                 3824 KB 
                 5824 KB 
                 4496 KB 
               
               
                   
                 Size 
               
               
                 Array 
                 Total 
                 48 
                 4 
                 30 
               
               
                 Closure 
                 Paths 
               
               
                 Algorithm 
                 Time 
                  0.3 sec 
                 0.01 sec 
                 0.44 sec 
               
               
                   
                 Memory 
                 4760 KB 
                 2728 KB 
                 4280 KB 
               
               
                   
                 Size 
               
               
                   
               
             
          
         
       
     
         [0101]    In short, this invention provides two algorithms of searching paths suffering from ESD. The two algorithms may work in a flattened circuit and find the paths that are suffering from ESD in a circuit with millions of logic gates. According to this invention, the tool of analysis on the paths suffering from ESD comprises input netlists, circuit flattening, the supernode algorithm, and the array closure algorithm that analyzes the paths suffering from ESD and outputs them for design reference of ESD guard circuit. 
         [0102]    To sum up, the method provided in this invention may further serve as a suite of computer-aided simulation software that protect the circuit from ESD, may determine the paths in the circuit against ESD at the beginning of circuit design, and may effectively save the time and reduce resources in circuit design. 
         [0103]    While the invention has been described in terms of what is presently considered to be the most practical and preferred embodiments, it is to be understood that the invention needs not be limited to the disclosed embodiment. On the contrary, it is intended to cover various modifications and similar arrangements included within the spirit and scope of the appended claims which are to be accorded with the broadest interpretation so as to encompass all such modifications and similar structures.