# Patent

## Title
Timing verification method for circuits

## Abstract

The timing verification method for stochastic networks and circuits is a computerized method that includes a Valued-Sum-of-Products (VSOP) tool as an extension to Zero-suppressed Binary Decision Diagrams (ZBDD) to compute and store paths with their corresponding lengths or statistical parameters. This method starts from source vertices and inductively builds a path database in the topological order of gates. At each node the method builds a set of partial paths that terminated that node using VSOP expressions. Path queries are performed on all paths using VSOP operations, thereby querying the top K-most critical paths in integrated circuit networks.

## Background
BACKGROUND OF THE INVENTION
1. Field of the Invention
The present invention relates to circuit design, and particularly to a timing verification method for stochastic networks and circuits that provides a computerized method that includes a non-enumerative path length analysis algorithm for deterministic and stochastic directed acyclic graphs (DAGs) with applications to timing verification of circuits.
2. Description of the Related Art
A combinational logic circuit can be represented as a timing graph that describes the logic gates in the circuit with the directional connections between different gates. Program evaluation and review technique (PERT) is popularly used in static timing analysis, it is also known as the CPM (critical path method), which is the most widely used technique, used for delay calculations. CPM can be used to calculate the worst-case delay of a combinational circuit. Critical paths, required times and slacks are also a number of timing parameters for a combinational circuit that can also be calculated. Incremental timing analysis can be used to speed up the delay calculation. A negative aspect of the CPM is that of false paths, which results because the CPM completely ignores the Boolean relationships in a circuit, and works with purely topological properties. This renders the critical path delay found using CPM as pessimistic in the most general cases.
Thus, a timing verification method for stochastic networks and circuits solving the aforementioned problems is desired.
SUMMARY OF THE INVENTION
The timing verification method for stochastic networks and circuits includes a Valued-Sum-of-Products (VSOP) tool as an extension to Zero-suppressed Binary Decision Diagrams (ZBDD) to compute and store paths with their corresponding lengths or statistical parameters. This method starts from source vertices and inductively builds a path database in the topological order of gates. At each node the method builds a set of partial paths that terminated that node using VSOP expressions. Path queries are performed on all paths using VSOP operations thereby querying the top K most critical paths in integrated circuit networks.
These and other features of the present invention will become readily apparent upon further review of the following specification and drawings.



BRIEF DESCRIPTION OF THE DRAWINGS
FIG. 1 is a table providing the steps of a first algorithm of the timing verification method for deterministic and stochastic networks and circuits according to the present invention.
FIG. 2 is a table providing the steps of a second algorithm of the timing verification method for deterministic and stochastic networks and circuits according to the present invention.
FIG. 3 is a table providing the steps of a third algorithm of the timing verification method for deterministic and stochastic networks and circuits according to the present invention.
FIG. 4 is a table providing the steps of a fourth algorithm of the timing verification method for deterministic and stochastic networks and circuits according to the present invention.
FIG. 5 is a table providing the steps of a fifth algorithm of the timing verification method for deterministic and stochastic networks and circuits according to the present invention.
FIG. 6 is a table providing the steps of a sixth algorithm of the timing verification method for deterministic and stochastic networks and circuits according to the present invention.
FIG. 7 is a table providing the steps of a seventh algorithm of the timing verification method for deterministic and stochastic networks and circuits according to the present invention.
FIG. 8 is a table providing the steps of an eighth algorithm of the timing verification method for deterministic and stochastic networks and circuits according to the present invention.
FIG. 9 is a table of F term's encoding of the timing verification method for deterministic and stochastic networks and circuits according to the present invention.
FIG. 10 is a diagram showing an exemplary path of the timing verification method for deterministic and stochastic networks and circuits according to the present invention.
FIG. 11 is a table of VSOP operations of the timing verification method for deterministic and stochastic networks and circuits according to the present invention.
FIG. 12 is a graph showing a statistical SUM operation of the timing verification method for deterministic and stochastic networks and circuits according to the present invention.
FIG. 13 is a waveform diagram showing a statistical SUMMAX operation of the timing verification method for deterministic and stochastic networks and circuits according to the present invention.
FIG. 14 is a schematic diagram showing an exemplary delay fault in the timing verification method for deterministic and stochastic networks and circuits according to the present invention.
FIG. 15 is a schematic diagram showing a ZBDD-based coverage calculation of a timing verification method for deterministic and stochastic networks and circuits according to the present invention.
FIG. 16 is a schematic diagram of a test circuit for a timing verification method for deterministic and stochastic networks and circuits according to the present invention.
FIG. 17A is a diagram showing a frequency of node pairs of the timing verification method for deterministic and stochastic networks and circuits according to the present invention.
FIG. 17B is a diagram showing a frequency of node tuples of the timing verification method for deterministic and stochastic networks and circuits according to the present invention.
FIG. 18 is table showing the sum of powers of path lengths in a timing verification method for deterministic and stochastic networks and circuits according to the present invention.
FIG. 19 is diagram showing overlapping subpaths in a timing verification method for deterministic and stochastic networks and circuits according to the present invention.
FIG. 20 is table of circuit descriptions in a timing verification method for deterministic and stochastic networks and circuits according to the present invention.
FIG. 21 is a table of costs in a timing verification method for deterministic and stochastic networks and circuits according to the present invention.
FIG. 22 is table of 10th moment costs in a timing verification method for deterministic and stochastic networks and circuits according to the present invention.
FIG. 23 is a table of basic deterministic path delay results in a timing verification method for deterministic and stochastic networks and circuits according to the present invention.
FIG. 24 is a table of partition-based deterministic path delay results in a timing verification method for deterministic and stochastic networks and circuits according to the present invention.
FIG. 25 is a table of basic stochastic path delay results in a timing verification method for deterministic and stochastic networks and circuits according to the present invention.
FIG. 26 is a table of partition-based algorithm results in a timing verification method for deterministic and stochastic networks and circuits according to the present invention.
FIG. 27A is a diagram showing the forward and backward path count values at every node in a timing verification method for deterministic and stochastic networks and circuits according to the present invention.
FIG. 27B is a diagrams depicting the subgraph rooted at ν8 along with local forward path count values in a timing verification method for deterministic and stochastic networks and circuits according to the present invention.
FIG. 28 is a graph showing exemplary deterministic edge costs in a timing verification method for deterministic and stochastic networks and circuits according to the present invention.



Similar reference characters denote corresponding features consistently throughout the attached drawings.
DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS
The timing verification method for stochastic networks and circuits includes a novel non-enumerative path length analysis algorithm for deterministic and stochastic directed acyclic graphs (DAGs) with applications to timing verification of circuits, the algorithm computing statistical measures of path lengths without storing and/or manipulating the paths in such networks. The timing verification method is able to compute deterministic or probabilistic costs assigned to edges, vertices, or both.
Networks or graphs are fundamental modeling tools in mathematics and computing. They model many applications and enable us to map the problems of a modeled application to well-studied graph problems. Networks include nodes, i.e., vertices, and edges. Often, costs are assigned to the nodes as well as edges. The costs may be deterministic, or stochastic, i.e., random variables. When costs are stochastic, networks are called stochastic networks; otherwise, the networks are deterministic.
This disclosure introduces algorithms to find the top K most critical paths or some statistical measures of path lengths in stochastic/deterministic networks. Moreover, these algorithms are applied to the timing verification and testing of digital circuits. More specifically, statistical parameters of path lengths are computed without operating on full paths. Additionally, all or selected paths along with their corresponding lengths are stored. In circuit timing analysis, lengths/costs are delays in circuits; therefore, path lengths are path delays. The inventive algorithms disclosed herein aim at addressing the problem of exponential growth in the number of paths. The inventive algorithms avoid path enumeration in their computations because path enumeration is infeasible. Paths which avoid enumeration are called non-enumerative paths.
With regard to the statistical parameters, calculations include the mean, variance, skewness, kurtosis, and, in general, kth central moment of the path lengths of deterministic network. For stochastic networks, calculations of the expected length and variance of paths are performed. In both network types, dependencies among the paths are taken into consideration. Using these calculated parameters and a few probability inequalities, some conclusions are drawn about the paths such as the number of paths within an interval relative to the mean. The inventive algorithm for computing some statistical measures of deterministic networks requires O(k2·(V+E)) time and O(k·(V+E)) memory space. For stochastic networks, the algorithm requires O(k2·(V+E)) time to compute up to the kth moments of expected path lengths while O((V+E)2) time to compute the average variance of path lengths. The memory space requirement is the same as the deterministic network case. This algorithm does not store any full or even partial paths.
The second algorithm stores the paths along with their respective lengths and variances. This serves as a path database to length-involving queries. For example, the statistical parameters targeted by the first problem can also be calculated from this database. Additionally, the top K paths, the low K paths, the middle K paths, and, in general, the paths within a specified length interval may be queried. This approach can handle prohibitively large paths that makes it superior to the existing top-K-paths finding algorithms since they would fail when the number of the top K paths is exponential.
The algorithms to solve the second problem and its derivatives are inspired by the recent usage of a Zero-suppressed Binary Decision Diagrams (ZBDD) tool in path delay fault (PDF) coverage calculation and the availability of a Valued-Sum-of-Products (VSOP) tool which is an extension to the ZBDD tool. The algorithms are all non-enumerative algorithms. The algorithms may encounter memory overflow during their computations. In this case, the algorithms would be run on partitioned graphs to avoid memory overflow that causes the memory swapping, which in turn increase the run times.
These inventive algorithms are applied to the timing analysis and verification of (digital) VLSI circuits. More specifically, these algorithms are used to find the top K most critical-delay paths in circuits when the delays in circuits are modeled either deterministic or stochastic. The most critical path in a circuit specifies the (static) timing performance of the circuit, i.e., the clock speed. The method of finding the most critical path in a deterministic-delay (stochastic-delay) model of a circuit is called (statistical) static timing analysis. Furthermore, manufacturing process or deep submicron technology limitations can cause a manufactured circuit to deviate from its specified timing performance. To detect such deviations, manufactured circuits are tested for timing performance. This is called delay testing of circuits.
One delay testing model, called path delay fault testing, tests all of the paths for propagation time of signal transitions along the paths. The inventive path delay fault testing algorithm is used to perform the delay testing only on the top K most critical-delay paths rather than all paths.
See the short tutorial on VSOP tool and detailed background information about the utilized statistical and probabilistic measures, (statistical) static timing analysis, and path delay fault coverage calculation, infra. Moreover, as discussed infra, the inventive methods calculate the statistical measures of path lengths, i.e., path delays in circuit domains. This patent application also discusses the two inventive VSOP-based applications and related algorithms. Moreover, the algorithm to find the top K most critical paths in circuits is presented. A new path delay fault coverage calculation algorithm is devised to report the fraction of the top K most critical paths tested for delay faults. Performances of the inventive algorithms are evaluated with selected 15CA585, ISCAS89, and ITC99 circuits and the results are given infra.
With respect to Valued-Sum-of-Product (VSOP) Tool based on ZBDDs, a combinatorial item set is a set of elements each of which is a combination out of n items. Zero-suppressed Binary Decision Diagrams (ZBDDs) are special type of Binary Decision Diagrams (BDDs) that are designed for implicit representation and efficient manipulation of combinatorial item sets. The manipulation time is proportional to the size of the underlying ZBDD. Therefore, ZBDDs utilize certain reduction rules to compactly represent a set. The size of a ZBDD is also sensitive to the order of items (i.e., variables) in a ZBDD. Many static and dynamic variable ordering approaches are investigated for that purpose.
In an exemplary ZBDD Let F={abc, ab, bc} be a combinatorial item set. The set of items in F are {a, b, c}. FIG. 10 illustrates the ZBDD 1000 for F. The items are ordered as a being the first, b being the second, and c being the third. 0-edges are represented by the dashed lines, while 1-edges are represented by the solid lines. Each path from the root to leaf 1 corresponds to a combination in the set. In a path, a solid (dashed) outgoing edge from a node indicates that the respective item is included (excluded) in (from) the combination.
Valued-Sum-of-Product (VSOP) is an extension to ZBDD, and supports assignment of values to the terms in a sum-of-products expression and enables efficient manipulation of expressions. For example, E=2ab+ac−3bd is a VSOP expression where terms ab, ac, and bd have 2, 1, and −3 values, respectively. In VSOP algebra, addition and subtraction follow the ordinary rule (a+a=2a) but the multiplication does not, and a×a=a, not 2a. VSOP adopts the base (−2) binary encoding of numbers and an integer number is decomposed into an n-digit vector of ZBDD {F0, F1, . . . , Fn−1}. Fi is a ZBDD and stores the terms which have a 1 in their (i+1)th digits in their encodings. Specifically, F0 is the set of odd-valued terms, F1 is the set of terms which have a 1 in the second position etc.
Example 2
The VSOP expression F=4abc+5ab+3bc+a is represented in VSOP as in Table 90 shown in FIG. 9. The encoding yields F0={ab, bc, a}, F1={bc}, and F2={abc, ab, bc}.
The following VSOP operations are used in the following sections and their details are known to skilled artisans:

    
    
        E1.Perrnit (E2): Extract terms in E1 each of which is included in one of combinations in E2.
        E1.Restrict (E2): Extract terms in E1 each of which includes one of combinations in E2.
        E1.TermsQP (E2): Filter terms in E1 “OP” to the constant term of E2 where OP={EQ, NE, LE, LI, GT, CE}.
        E1 op E2: Two expressions are subject to arithmetic or logical operation op, where OP={+, −, *, 7, %, ==, !=, <, <=, >, >=}.
        E.CountTenns ( ): The number of minterms in expression E.
        E.TotalVal ( ), E.MaxVal ( ), E.MinVal ( ): Sum of the minterm values, maximum value in the set, and minimum value in the set.
    
    


Example 3
Let F=4abc+5ab+3bc+a and G=5ab−3bc. Some operations on F and G and their outcomes are tabulated in Table 1100 of FIG. 11. Comparison operations are better understood if we assume 0 coefficients for the nonexisting terms in G i.e., G=Oabc+5ab−3bc+Oa.
In the present method, we utilize some single and multivariate statistical and probabilistic measures to draw statistical conclusions about the path lengths in a network. These are (1) expected value of the sum of random variables, (2) variance of the sum of random variables, (3) the raw and central moments of a single random variable, and (4) probabilistic inequalities for single random variable case.
1) Expected value and Variance: The expected value of the sum of random variables is equal to the sum of the expected values of random variables (Eq. 1). This equation holds whether the variables are dependent or independent, and they have identical or different probability density functions. The variance of the sum of random variables (Eq. 2) is equal to the sum of the pairwise covariances of random variables where Cov [Xi, X]=Var [Xi] and Cov [Xi, Xj]=Cov [Xj, Xi]. Similar to expected value calculation, this equation is also valid when the variables are dependent and have different distributions.




  
    
      
        
          E
          ⁡
          
            [
            
              
                ∑
                
                  i
                  =
                  1
                
                N
              
              ⁢
              
                X
                i
              
            
            ]
          
        
        =
        
          
            ∑
            
              i
              =
              1
            
            N
          
          ⁢
          
            E
            ⁡
            
              [
              
                X
                i
              
              ]
            
          
        
      
    
    
      
        (
        1
        )
      
    
  








  
    
      
        
          V
          ⁡
          
            [
            
              
                ∑
                
                  i
                  =
                  1
                
                N
              
              ⁢
              
                X
                i
              
            
            ]
          
        
        =
        
          
            ∑
            
              i
              =
              1
            
            N
          
          ⁢
          
            
              ∑
              
                j
                =
                1
              
              N
            
            ⁢
            
              Cov
              ⁡
              
                [
                
                  
                    X
                    i
                  
                  ,
                  
                    X
                    j
                  
                
                ]
              
            
          
        
      
    
    
      
        (
        2
        )
      
    
  








  
    
      
        
          
            ∑
            
              i
              =
              1
            
            N
          
          ⁢
          
            V
            ⁡
            
              [
              
                X
                i
              
              ]
            
          
        
        +
        
          2
          ⁢
          
            
              ∑
              
                i
                <
                j
              
              N
            
            ⁢
            
              Cov
              ⁡
              
                [
                
                  
                    X
                    i
                  
                  ,
                  
                    X
                    j
                  
                
                ]
              
            
          
        
      
    
    
      
        (
        3
        )
      
    
  




2) Moments, Skewness and Kurtosis: The k-th raw moment (μk′) and k-th central moment (μk) of a probability function are computed according to Eq. 4 and 5, respectively. The second central moment about the mean (μ) is the variance (μ2=σ2), the positive square root of which is the standard deviation (σ). For a given population, Eq. (7) computes the k-th raw (k-th central) moments. Moreover, Eq. 8 defines the relationship among the moments. The normalized third central moment is called skewness (Eq. 9) while the normalized fourth central moment minus 3 is called kurtosis (Eq. 10). The value of skewness is positive (negative) when the distribution is skewed to the right (left). The value of kurtosis specifies the peakedness of the distribution. Also, μ4 of a normal distribution is 3σ4 so for a normal distribution γ4=0.




  
    
      
        
          μ
          k
          ′
        
        =
        
          E
          ⁡
          
            [
            
              X
              k
            
            ]
          
        
      
    
    
      
        (
        4
        )
      
    
  








  
    
      
        
          μ
          k
        
        =
        
          E
          ⁡
          
            [
            
              
                (
                
                  X
                  -
                  μ
                
                )
              
              k
            
            ]
          
        
      
    
    
      
        (
        5
        )
      
    
  








  
    
      
        
          μ
          k
          ′
        
        =
        
          
            
              ∑
              
                i
                =
                1
              
              N
            
            ⁢
            
              X
              i
              k
            
          
          N
        
      
    
    
      
        (
        6
        )
      
    
  








  
    
      
        
          μ
          k
        
        =
        
          
            
              ∑
              
                i
                =
                1
              
              N
            
            ⁢
            
              
                (
                
                  
                    X
                    i
                  
                  -
                  μ
                
                )
              
              k
            
          
          N
        
      
    
    
      
        (
        7
        )
      
    
  








  
    
      
        
          μ
          k
        
        =
        
          
            
              
                ∑
                
                  i
                  =
                  0
                
                k
              
              ⁢
              
                
                  (
                  
                    -
                    1
                  
                  )
                
                i
              
            
            N
          
          ·
          
            (
            
              
                
                  k
                
              
              
                
                  i
                
              
            
            )
          
          ·
          
            μ
            
              k
              -
              i
            
            ′
          
          ·
          
            μ
            i
          
        
      
    
    
      
        (
        8
        )
      
    
  








  
    
      
        
          γ
          1
        
        =
        
          
            μ
            3
          
          
            σ
            3
          
        
      
    
    
      
        (
        9
        )
      
    
  








  
    
      
        
          γ
          2
        
        =
        
          
            
              μ
              4
            
            
              σ
              4
            
          
          -
          3
        
      
    
    
      
        (
        10
        )
      
    
  




3) Probabilistic Inequalities: We use three probabilistic inequalities in this article. These are kth moment bound, Chebyshev's Inequality (Eq. 12), and Cantelli's Inequality (Eq. 13). These theorems do not make any assumption about the underlying probability distributions. The k-th moment bound states that a random variable (X) will take on a value greater than or equal to a real number δ(δ>0) is at most




  
    
      E
      ⁡
      
        [
        
          
            
            X
            
          
          k
        
        ]
      
    
    
      δ
      k
    
  
  .




Chebyshev's theorem finds the probability that a random variable (X) will take on a value within k standard deviations of the mean (i.e., μ−kσ≦X≦μ+kσ) is at least





  
    1
    -
    
      1
      
        k
        2
      
    
  
  ,




where k is a positive real number. Similarly, Cantelli's theorem (a.k.a. one-sided Chebyshev's inequality) finds the probability that a random variable (X) will take on a value greater than or equal to k standard deviations of the mean (X≧μ+kσ) is at most





  
    1
    
      1
      +
      
        k
        2
      
    
  
  ,
  
    k
    >
    0.
  








  
    
      
        
          Pr
          ⁡
          
            (
            
              
                
                X
                
              
              ≥
              δ
            
            )
          
        
        ≤
        
          
            E
            ⁡
            
              [
              
                
                  
                  X
                  
                
                k
              
              ]
            
          
          
            δ
            k
          
        
      
    
    
      
        (
        11
        )
      
    
  








  
    
      
        
          Pr
          ⁡
          
            (
            
              
                
                
                  X
                  -
                  μ
                
                
              
              ≥
              
                k
                ⁢
                
                  
                
                ⁢
                δ
              
            
            )
          
        
        ≤
        
          1
          
            k
            2
          
        
      
    
    
      
        (
        12
        )
      
    
  








  
    
      
        
          Pr
          ⁡
          
            (
            
              
                X
                -
                μ
              
              ≥
              
                k
                ⁢
                
                  
                
                ⁢
                δ
              
            
            )
          
        
        ≤
        
          1
          
            1
            +
            
              k
              2
            
          
        
      
    
    
      
        (
        13
        )
      
    
  




4) Omnibus Test for Normality: An omnibus test is a term that refers to a test that considers both the skewness and kurtosis. They are useful as they assess two types of possible non-normality concurrently; if either the skewness or kurtosis (or both) is too extreme then the test will reject the hypothesis that the data comes from a normal distribution. The D'Agostino's K2 test, the Jarque-Bera test, and the Shapiro-Wilk test are examples of omnibus tests. The Jarque-Bera test is simple compared with the other two, and has a Chi-Squared distribution with 2 degrees of freedom. Therefore, we give its formula below for a sample of size N.




  
    
      
        JB
        =
        
          
            N
            6
          
          ⁢
          
            (
            
              
                γ
                1
                2
              
              +
              
                
                  γ
                  2
                  2
                
                4
              
            
            )
          
        
      
    
    
      
        (
        14
        )
      
    
  




Regarding Critical Paths Problem in Networks, Activity Networks and PERT, examples of large and complex projects, are better managed when the activities and milestones in them are clearly defined. The activities, their durations and milestones, as well as the dependencies among the activities are captured in a network form. In original modeling, the activities were modeled with arcs while milestones were modeled with nodes, therefore, this model is called the activity-on-arc network, Later, some people preferred to model activities with nodes and milestones with arcs, called the activity-on-node network. The critical paths of such networks indicate the total calendar time required to complete the project.
The durations of activities in a network can be fixed time estimates or varying time estimates modeled with random variables. The Critical Path Method (CPM) is a deterministic method that uses a fixed time estimate for each activity. While CPM is easy to use, it does not consider the time variations that can have a great impact on the completion time of a large and complex project with huge number of activities. On the other hand, the Program Evaluation and Review Technique (PERT) allows for randomness in activity completion times and has the potential to reduce both the time and cost required to complete a project.
In stochastic PERT networks, the project completion time is a random variable and project managers are interested in the probability density function (pdf) of the completion time to manage the project better. Computing the pdf of the project completion time is NP-hard problem. Skilled artisans give a classification of approaches to solve this problem. The approaches include (i) exact analysis, (ii) Monte Carlo simulations, (iii) approximation approaches, and (iv) analytical bounding of completion time pdf.
2) (Statistical) Static Timing Analysis of Circuits: Static timing analysis method finds the timing performance of a circuit by performing a static analysis on the circuit while dynamic timing analysis method measures the performance of a circuit with respect to a set of simulated input stimuli. In deterministic modeling of circuit, the delays of design components are fixed and the timing performance of a circuit is simply the longest path delay after the false-paths are eliminated. However, process variations cause delay specifications of design components to be modeled with random variables. This modeling results in stochastic network modeling of circuits and finding the probability density function of the timing performance of the underlying circuit is called Statistical Static Timing Analysis (SSTA). FIG. 12 depicts statistical sum operation 12 modeling of gates with random variables and the delay of path as the sum of these two random variables.
Two probabilistic analysis methods are proposed for SSTA: (1) path-based approaches and (2) block-based approaches. In path-based SSTA algorithms, a set of potentially critical paths is identified, and a statistical static timing analysis is performed on these paths to approximate the probability density function of path delays. First, the delay distribution of each path is found by statistically summing the delays of all its nodes and edges as illustrated in FIG. 12. The delay distribution of timing performance is found by performing a statistical maximum operation over all the path delays, i.e., MAX (D1, D2, . . . , DN) where D is the random variable for the delay distribution of the ith path. Circuit 13 of FIG. 13 depicts the MAX operation applied to the probability density functions of a gate's inputs.
In block-based SSTA algorithms, both fall and rise times are propagated to each gate and statistical MAX operation is invoked at each gate in the circuit. Calculation of MAX of correlated signals at each gate is considered the hard part of this approach. On the other hand, this approach's run time is linear with circuit size while the run-time of the path-based approach is proportional to the number of paths, which is exponential with respect to the circuit size in most cases.
The present method's SSTA algorithms, presented in the following sections, fall in the category of path-based approaches and find the actual paths along with their expected delays and delay variances. Moreover, correlation among the signals is taken into consideration.
3) Path Delay Fault Coverage Calculation of Circuits: Manufactured circuits may include defects that violate the timing requirements of the circuits, i.e. the specified clock period. Artisans having ordinary skill are aware of several delay defect fault models to automate their detections and diagnoses. Path delay fault model is one of them. In this model, two delay fault models are associated with every path in a circuit: (1) slow-to-fall and (2) slow-to-rise. To detect a slow-to-fall (slow-to-rise) path delay fault, a falling (rising) signal is propagated through the corresponding path and the propagation time is measured. If the signal arrives later than the expected time, then there is a delay defect affecting this particular path. Circuit and timing diagram 14 of FIG. 14 illustrates propagation of a falling signal on path y z. If there is a defect affecting this path, then the signal z would arrive after the clock transition. As a result, the incorrect value would be stored in the flip-flop (FF). The goal of delay testing is to reveal such delay defects.
The general procedure in delay fault testing includes fault modeling, test vector generation, coverage calculation, test vector set compaction, and test vector application to the manufactured circuits. Under path delay fault model, the number of faults in a circuit is equal to twice the number of paths in a circuit. There are circuits with exponential number of paths, e.g., c6288≈1020 and b18≈1021 paths. Therefore, algorithms are developed to find the test vectors, and coverages without path enumeration. Also, it has been proven that finding coverage is an NP-hard problem.
The state-of-the-art coverage calculation algorithm utilizes ZBDDs to efficiently and non-enumeratively grade the test set and report the coverage value, i.e., the fraction of the detected paths (Eq. 15). The basic ZBDD based approach simulates a vector pair to propagate signals along some paths in a circuit, and then uses ZBDD-operations to build the set of paths detected by a test vector inductively as illustrated in circuit 15 of FIG. 15, which is c17 circuit 16 in FIG. 16. The approach is repeated for every vector. The union of all sets yields the set of all detected paths and its size is the coverage value. When the basic approach causes memory overflow, the partition-based approach is used to calculate the coverage. The state-of-the-art partition-based algorithm is called PeCoCa by skilled artisans.




  
    
      
        Coverage
        =
        
          DetectedPaths
          TotalPaths
        
      
    
    
      
        (
        15
        )
      
    
  




The state-of-the-art coverage calculation algorithms do not take into account the actual delays of the paths. A high coverage value may not indicate the coverage of potentially critical paths. Therefore, a better coverage metric (Eq. 16) would be the fraction of detected potentially-critical paths. In Eq. 16, Total paths≧l (Detected paths≧l) is the number of total (detected) paths whose delays are at least l. In the following sections, we devise algorithms to calculate the coverage of the potentially critical paths.




  
    
      
        
          Coverage
          
            ≥
            l
          
        
        =
        
          
            Detected
            ⁢
            
              
            
            ⁢
            
              Paths
              
                ≥
                l
              
            
          
          
            TotalPaths
            
              ≥
              l
            
          
        
      
    
    
      
        (
        16
        )
      
    
  




Path counting methods utilize the concept of the frequency of a node or a node sequence. Therefore, first, it is defined, and next given some algorithms to calculate the frequencies. The frequency of a node is defined as the number of paths in which this node occurs. Similarly, the frequency of a node sequence is the number of paths in which this node sequence occurs together.
The frequency of node νi(fi) is equal to the number of incoming paths ({right arrow over (f)}i) times the number of outgoing paths ({right arrow over (f)}i) (Eq. 17). {right arrow over (f)}i/i is computed with the forward/backward path counting algorithm. Moreover, the number of paths between two nodes, e.g., νi and νj is also computed as follows. Assuming that νi comes topologically before νj in the graph, we identify the output cone of νi (all of the nodes which depend on νi), and run the forward path counting on this subgraph whose only source vertex is νi. This computation gives us the numbers of paths between νi and all of its dependent nodes such as νj ({tilde over (f)}i,j) in this subgraph. FIG. 17A illustrates this subgraph concept for node pairs 17a while FIG. 17B depicts the same for a node sequence 17b (νi·νi+1 . . . νi+n).
The number of paths in which νi and νj (fi,j) occur together is given by Eq. 18. Eq. 19 computes the frequency figure for a sequence of nodes.




  
    
      
        
          f
          i
        
        =
        
          
            
              f
              i
            
            ->
          
          ·
          
            
              f
              i
            
            ←
          
        
      
    
    
      
        (
        17
        )
      
    
  








  
    
      
        
          f
          
            i
            ,
            j
          
        
        =
        
          
            
              
                f
                i
              
              ->
            
            ·
            
              
                f
                ij
              
              ~
            
          
          ⁢
          
            
              f
              j
            
            ←
          
        
      
    
    
      
        (
        18
        )
      
    
  








  
    
      
        
          f
          
            i
            ⁢
            
              ,
              1
            
            ,
            
              i
              2
            
            ,
            
              i
              3
            
            ,
            ...
            ⁢
            
              
            
            ,
            
              i
              n
            
          
        
        =
        
          
            
              f
              
                i
                1
              
            
            ->
          
          ·
          
            (
            
              
                
                  ∏
                  
                    j
                    =
                    1
                  
                  
                    n
                    -
                    1
                  
                
                ⁢
                
                  
                
                ⁢
                
                  
                    f
                    ij
                  
                  ~
                
              
              ,
              
                i
                
                  j
                  +
                  1
                
              
            
            )
          
          ·
          
            
              f
              ←
            
            
              i
              n
            
          
        
      
    
    
      
        (
        19
        )
      
    
  




Example 4
illustrates the frequency calculation with the running example graph (c17 in circuit 16 of FIG. 16). DAG Graph 2700a of FIG. 27A shows the forward and backward path count values at every node e.g., {right arrow over (f)}8, 8=(3, 2). The total number of paths in this DAG is 5+6=11, and ν1·ν6·ν10 is one of the paths. Graph 2700b of FIG. 27B depicts the subgraph rooted at ν8 along with local forward path count values. From graph 2700b, {tilde over (f)}7,8={tilde over (f)}7,9={tilde over (f)}7,10=1 and {tilde over (f)}7,11=2. Thus, f7,8={right arrow over (f)}7·{tilde over (f)}7,8·8=2.1.2=4. There are a total of 4 paths in which ν7 and ν8 both occur. These paths are ν2·ν7·ν8·ν10, ν2·ν7·ν8·ν11, ν3·ν7·ν8·ν10, and ν3·ν7·ν8·ν11.
Statistical measures of path delays are utilized by the present invention which includes an algorithm to non-enumeratively compute several statistical parameters of path lengths (i.e., path delays) in a circuit. These parameters help us to draw statistical conclusion about path delays, e.g., the approximate number of paths of certain delays. both deterministic and stochastic delay cost cases are considered.
Regarding measurement of deterministic path delays the assumption is that deterministic delay values are assigned to the gates and wires in a gate-level circuit. Thus, path delays are deterministic. For this case, we compute sum of the kth powers of path delays,




  
    ∑
    
      i
      =
      1
    
    PC
  
  ⁢
  
    l
    i
    k
  




where PC is the number of paths, li is the delay of the ith path in the circuit, and k is a non-negative integer. From this sum, calculate mean (μ), standard deviation (σ or √{square root over (μ2)}), variance (σ2 or μ2), skewness (γ1), and kurtosis (γ2) of path delays. In general, the algorithm calculates the nth raw moment (μn′) and nth standardized moment





  (
  
    
      μ
      n
    
    
      σ
      n
    
  
  )




of the path delays. The formulae for the mean path delay (μ) the nth central moment (μn) and the numerator of μn, are given in Eq. 20, Eq. 21, and Eq. 22, respectively.





  
    
      
        μ
        =
        
          
            
              ∑
              
                i
                =
                1
              
              PC
            
            ⁢
            
              l
              i
            
          
          PC
        
      
    
    
      
        (
        20
        )
      
    
  








  
    
      
        
          μ
          n
        
        =
        
          
            
              ∑
              
                i
                =
                1
              
              PC
            
            ⁢
            
              
                (
                
                  
                    l
                    i
                  
                  -
                  μ
                
                )
              
              n
            
          
          PC
        
      
    
    
      
        (
        21
        )
      
    
  








  
    
      
        
          
            ∑
            
              i
              =
              1
            
            PC
          
          ⁢
          
            
              (
              
                
                  l
                  i
                
                -
                μ
              
              )
            
            n
          
        
        =
        
          
            ∑
            
              k
              =
              0
            
            n
          
          ⁢
          
            
              (
              
                
                  
                    n
                  
                
                
                  
                    k
                  
                
              
              )
            
            ·
            
              
                (
                
                  -
                  μ
                
                )
              
              
                n
                -
                k
              
            
            ·
            
              (
              
                
                  ∑
                  
                    i
                    =
                    1
                  
                  PC
                
                ⁢
                
                  l
                  i
                  k
                
              
              )
            
          
        
      
    
    
      
        (
        22
        )
      
    
  




The heart of the problem is the computation of the sum of the kth powers of paths' lengths. This sum is reformulated and solved with dynamic programming method that utilizes Eq. 8. The following notations are used in our formulation:

    
    
        1) PCν: the number of partial paths up to vertex ν,
        2) I(ν): the set of ν's input vertices,
        3) cw,ν: the cost of edge between vertices w and v,
        4) cν: the cost of vertex ν(default cν=1),
        5) lν(i)k: the kth power of the ith partial path's length at ν,
        where lν(i)k is cνk at the source vertices, and
        6) Sν(k): sum of the kth powers of partial paths' lengths at vertex ν.
    
    


A recursive formulation is given for Sν(k) in Eqns. 23-25. At a source vertex ν, PCν=1 and lν(i)k=cνk, where the default cν=1. Eq. 25 indicates that we need Sν(i) values for i=0, . . . , k at every vertex ν. These values can be recomputed on demand or computed once and stored for future use. Since k values would be usually small, we choose to store and reuse these values, Furthermore, Sν(k) can be calculated more efficiently by looking-up combination values from a precomputed Pascal triangle of k rows and incrementally computing powers of edge/vertex costs. Thus, the algorithm is invoked with k to compute Sν(0), . . . , Sν(k) values at ν that requires O(k2·(V+E)) overall run time. Moreover, vertex costs can also be incorporated into the equations by simply substituting cw,ν with the sum of associated edge and vertex costs, i.e., cw/ν+cν. However, Eq. 23, 24 and 25 can be further simplified if only vertex costs arc considered. For this case, the simplified formulation is given in Eq. 26.




   
  
    
      
        
          
            S
            
              v
              ⁡
              
                (
                k
                )
              
            
          
          =
          
          ⁢
          
            (
            
              
                ∑
                
                  i
                  =
                  1
                
                PC
              
              ⁢
              
                l
                i
                k
              
            
            )
          
        
      
      
        
          
          ⁢
          
            (
            23
            )
          
        
      
    
    
      
        
          =
          
          ⁢
          
            
              ∑
              
                w
                ∈
                
                  I
                  ⁡
                  
                    (
                    v
                    )
                  
                
              
            
            ⁢
            
              
                ∑
                
                  i
                  =
                  1
                
                
                  PC
                  w
                
              
              ⁢
              
                
                  (
                  
                    
                      l
                      
                        w
                        ⁡
                        
                          (
                          i
                          )
                        
                      
                    
                    +
                    
                      c
                      
                        w
                        ,
                        v
                      
                    
                  
                  )
                
                k
              
            
          
        
      
      
        
                                                                        
          ⁢
          
            (
            24
            )
          
        
      
    
    
      
        
          =
          
          ⁢
          
            
              ∑
              
                j
                =
                0
              
              k
            
            ⁢
            
              
                (
                
                  
                    
                      k
                    
                  
                  
                    
                      j
                    
                  
                
                )
              
              ·
              
                c
                
                  w
                  ,
                  v
                
                
                  k
                  -
                  j
                
              
              ·
              
                S
                
                  w
                  ⁡
                  
                    (
                    j
                    )
                  
                
              
            
          
        
      
      
        
          
          ⁢
          
            (
            25
            )
          
        
      
    
  








  
    
      
        
          S
          
            v
            ⁡
            
              (
              k
              )
            
          
        
        =
        
          
            ∑
            
              j
              =
              0
            
            k
          
          ⁢
          
            (
            
              
                (
                
                  
                    
                      k
                    
                  
                  
                    
                      j
                    
                  
                
                )
              
              ·
              
                c
                v
                
                  k
                  -
                  j
                
              
              ·
              
                
                  ∑
                  
                    w
                    ∈
                    
                      I
                      ⁡
                      
                        (
                        v
                        )
                      
                    
                  
                
                ⁢
                
                  S
                  
                    w
                    ⁡
                    
                      (
                      j
                      )
                    
                  
                
              
            
            )
          
        
      
    
    
      
        (
        26
        )
      
    
  




Path counting algorithms can be used to find the total path count (PC) in a DAG in O(V+E) time. The forward path counting algorithm assigns 1 to all source vertices, and sums the path count values at the input vertices of a vertex to get the path count value at this vertex. The total number of paths in a DAG is equal to the sum of the path counts at the sink vertices. Thus, like Sν(k) values, PC is also computed non-enumeratively. It can be verified that Sν(0) value at a vertex is equal to the value generated by the forward path counting algorithm at the same vertex. Therefore, the number of paths can be found by simply summing Sν(0) values at the sink vertices. As a result, we are able to calculate both numerator and denominator of νn without path enumeration. We illustrate νn's computation with an example.
Example 5
FIG. 28 is the same example graph showing deterministic edge costs 2800. In this graph, the average path length (μ), variance of path lengths (σ2 or μ2), μ3 and μ4 are 7, 2.73, −2.18, and 13.64, respectively. We apply Eq. 23-25 to compute Sνi(k) values and fill them in Table 18 of FIG. 18: rows are for k values and columns are for vertices. Column νs is for all source vertices. From these Sνi(k) values, the path count, mean, and central moments are computed. Central moments would be calculated according to Eq. 21 and 22. We calculate PC, μ. and μ2 from the table as follows.




  PC
  =
  
    
      
        S
        
          v
          ⁢
          
            
          
          ⁢
          10
          ⁢
          
            (
            0
            )
          
        
      
      +
      
        S
        
          v
          ⁢
          
            
          
          ⁢
          11
          ⁢
          
            (
            0
            )
          
        
      
    
    =
    11
  








  μ
  =
  
    
      
        
          S
          
            
              v
              10
            
            ⁡
            
              (
              1
              )
            
          
        
        +
        
          S
          
            
              v
              11
            
            ⁡
            
              (
              1
              )
            
          
        
      
      
        
          S
          
            
              v
              10
            
            ⁡
            
              (
              0
              )
            
          
        
        +
        
          S
          
            
              v
              11
            
            ⁡
            
              (
              0
              )
            
          
        
      
    
    =
    
      
        
          34
          +
          43
        
        
          5
          +
          6
        
      
      =
      7
    
  








  
    ∑
    
      
        (
        
          
            l
            i
          
          -
          7
        
        )
      
      2
    
  
  =
  
    
      
        
          (
          
            
              
                2
              
            
            
              
                0
              
            
          
          )
        
        ⁢
        
          
            (
            
              -
              7
            
            )
          
          2
        
        ⁢
        
          (
          
            
              S
              
                
                  v
                  10
                
                ⁡
                
                  (
                  0
                  )
                
              
            
            +
            
              S
              
                
                  v
                  11
                
                ⁡
                
                  (
                  0
                  )
                
              
            
          
          )
        
      
      +
      
        
          (
          
            
              
                2
              
            
            
              
                1
              
            
          
          )
        
        ⁢
        
          
            (
            
              -
              7
            
            )
          
          1
        
        ⁢
        
          (
          
            
              S
              
                
                  v
                  10
                
                ⁡
                
                  (
                  1
                  )
                
              
            
            +
            
              S
              
                
                  v
                  11
                
                ⁡
                
                  (
                  1
                  )
                
              
            
          
          )
        
      
      +
      
        
          (
          
            
              
                2
              
            
            
              
                2
              
            
          
          )
        
        ⁢
        
          
            (
            
              -
              7
            
            )
          
          0
        
        ⁢
        
          (
          
            
              S
              
                
                  v
                  10
                
                ⁡
                
                  (
                  2
                  )
                
              
            
            +
            
              S
              
                
                  v
                  11
                
                ⁡
                
                  (
                  2
                  )
                
              
            
          
          )
        
      
    
    ⇒
    
      
        49
        ·
        11
      
      -
      
        14
        ·
        77
      
      +
      569
    
    ⇒
    30
  








  
    μ
    2
  
  =
  
    
      30
      11
    
    =
    2.73
  




With respect to Measuring Stochastic Path Delays, the proposed deterministic approach in the previous section can be generalized to measure path delays in stochastic networks where gate and wire delays are specified with mean and variance pairs. From the expected values of gates and wires the followings can be computed directly with the aforementioned method for deterministic case by setting costs of edges/vertices to their mean values:

    
    
        1) the mean expected path delay value (μE),
        2) the variance of expected path delay values (σE), and
        3) the moments of expected path delay values.
    
    


Calculation of variance-related parameters requires additional care since covariances among the gates/wires create data dependency among path delays. We compute the mean variance (Eq. 27) from the path delay variances. The mean variance formula (Eq. 27) is re-formulated as in Eq. 28. In Eq. 28, fi is the number of paths in which random variable X, appears while fi,j is the number of paths in which random variable pairs (Xi and Xj) occur together. Also, σXi,Xj is the covariance of random variables Xi and Xj.




  
    
      
        
          
            σ
            _
          
          2
        
        =
        
          
            
              ∑
              
                i
                =
                1
              
              PC
            
            ⁢
            
              
            
            ⁢
            
              σ
              i
              2
            
          
          PC
        
      
    
    
      
        (
        27
        )
      
    
  








  
    
      
        
          
            ∑
            
              k
              =
              1
            
            PC
          
          ⁢
          
            σ
            k
            2
          
        
        =
        
          
            
              ∑
              
                i
                =
                1
              
              
                
                V
                
              
            
            ⁢
            
              
                f
                i
              
              ·
              
                σ
                
                  X
                  i
                
                2
              
            
          
          +
          
            
              ∑
              
                i
                =
                1
              
              
                
                V
                
              
            
            ⁢
            
              
                ∑
                
                  j
                  =
                  
                    i
                    +
                    1
                  
                
                
                  
                  V
                  
                
              
              ⁢
              
                2
                ·
                
                  f
                  
                    i
                    ,
                    j
                  
                
                ·
                
                  σ
                  
                    
                      X
                      i
                    
                    ,
                    
                      X
                      j
                    
                  
                  2
                
              
            
          
        
      
    
    
      
        (
        28
        )
      
    
  




The probabilistic inequalities can be utilized to find the approximate number of paths within certain interval under stochastic delay model. This is done as follows. Let μ be the mean path delay of maximum path delays, Since μ≧μE, μE+kσE≦μ+kσE. We convert this inequality to an equality: μE+lσE=μ+kσE l≧k. From Eq. 13,




  
    Pr
    ⁡
    
      (
      
        X
        ≥
        
          μ
          +
          
            l
            ⁢
            
              
            
            ⁢
            
              σ
              E
            
          
        
      
      )
    
  
  ≤
  
    1
    
      1
      +
      
        l
        2
      
    
  
  ≤
  
    
      1
      
        1
        +
        
          k
          2
        
      
    
    .
  




Therefore, Pr(X≧μE+kσE) is also an upper bound for Pr(X≧μ+lσE).

A first application, the top K most critical paths includes the algorithms that store all or select paths along with their parameters delays. The top K most critical paths are selected from this path database. Both deterministic delay and stochastic delay modeled circuits are considered.
To find the top K most critical path, we utilize a data-driven binary search (DUBS) algorithm (Algorithm 1), shown as pseudo code 10 in FIG. 1. Since sorting and index-based accessing to the paths is not possible, the DDBS algorithm uses non-enumerative VSOP operators to find the set of top K paths from the built path database. Also, in this algorithm, when




  
    
      ⌊
      
        
          max
          +
          min
        
        min
      
      ⌋
    
    =
    min
  
  ,




the search to find the set is repeated for min+1 in the last step. Otherwise, the algorithm would not terminate.

Algorithm 2 shown as pseudo code 20 in FIG. 2 starts from the source vertices and inductively builds the path database in the topological order of gates. At each node, the algorithm builds the set of partial paths that end this node. The sum of sink nodes' paths is the set of all paths along with their delays.
In algorithm 2, L and Li s are VSOP expressions, and Li==Li removes the values of terms in a VSOP expression. For example, ((2ab+3bc)==(2ab+3bc))ab+bc. The last loop takes the union of all paths that end at the sinks. After that path queries can be performed on all paths using VSOP operations. In this inventive algorithm, we query the top K most critical paths. Inductive building of a set of paths is illustrated with the example below.
Example 6
In FIG. 28, L2=c2·ν2, L3=c3·ν3 where ci is the cost associated with node νi. Thus, the partial paths at ν7 along with their delays, assuming the delays associated with nodes only, are computed as follows:




  
    
      
        
          L
          7
        
        =
        
        ⁢
        
          
            L
            2
          
          +
          
            L
            3
          
        
      
    
  
  
    
      
        
          
            ⟹
            
            ⁢
            
              c
              2
            
          
          ·
          
            v
            2
          
        
        +
        
          
            c
            3
          
          ·
          
            v
            3
          
        
        +
        
          
            (
            
              
                v
                2
              
              +
              
                v
                3
              
            
            )
          
          ·
          
            c
            7
          
          ·
          
            v
            7
          
        
      
    
  
  
    
      
        
          
            ⟹
            
            ⁢
            
              (
              
                
                  c
                  2
                
                +
                
                  c
                  7
                
              
              )
            
          
          ·
          
            v
            2
          
          ·
          
            v
            7
          
        
        +
        
          
            (
            
              
                c
                3
              
              +
              
                c
                7
              
            
            )
          
          ·
          
            v
            3
          
          ·
          
            
              v
              7
            
            .
          
        
      
    
  




The second algorithm 20 can be generalized to calculate the paths along with the kth powers of path delays. In another words, the coefficient of a path is the kth power of its delay. Equation 29 finds the set of paths along with the kth power of their corresponding delays at vertex ν. This approach maintains the paths and that is the key difference between 2nd algorithm 20 and first algorithm 10. The statistical values in first algorithm 10 can be computed with the non-enumerative VSOP operations. For example, from Eq. 29, we compute the sum of the kth power of the path delays (Eq. 30) and the mean path length (Eq. 31).




  
    
      
        
          L
          
            v
            ⁡
            
              (
              k
              )
            
          
        
        =
        
          
            (
            
              
                ∑
                
                  ω
                  ∈
                  
                    I
                    ⁡
                    
                      (
                      v
                      )
                    
                  
                
              
              ⁢
              
                
                  ∑
                  
                    j
                    =
                    0
                  
                  k
                
                ⁢
                
                  
                    (
                    
                      
                        
                          k
                        
                      
                      
                        
                          j
                        
                      
                    
                    )
                  
                  ·
                  
                    L
                    
                      w
                      ⁡
                      
                        (
                        j
                        )
                      
                    
                  
                  ·
                  
                    c
                    
                      w
                      ,
                      v
                    
                    
                      k
                      -
                      j
                    
                  
                
              
            
            )
          
          ·
          v
        
      
    
    
      
        (
        29
        )
      
    
  








  
    
      
        
          S
          
            v
            ⁡
            
              (
              k
              )
            
          
        
        =
        
          
            
              L
              
                v
                ⁡
                
                  (
                  k
                  )
                
              
            
            ·
            TotalVal
          
          ⁢
          
            
          
          ⁢
          
            (
            
              
            
            )
          
        
      
    
    
      
        (
        30
        )
      
    
  








  
    
      
        μ
        =
        
          
            
              ∑
              
                v
                ∈
                Sink
              
            
            ⁢
            
              
                
                  L
                  
                    v
                    ⁡
                    
                      (
                      1
                      )
                    
                  
                
                ·
                TotalVal
              
              ⁢
              
                
              
              ⁢
              
                (
                
                  
                
                )
              
            
          
          
            
              ∑
              
                v
                ∈
                Sink
              
            
            ⁢
            
              
                
                  L
                  
                    v
                    ⁡
                    
                      (
                      1
                      )
                    
                  
                
                ·
                CountTerms
              
              ⁢
              
                
              
              ⁢
              
                (
                
                  
                
                )
              
            
          
        
      
    
    
      
        (
        31
        )
      
    
  




When the basic delay calculation causes memory overflow, the inventive method uses a partition-level delay calculation algorithm (third algorithm 30 of FIG. 3). This algorithm 30 joins all the partial paths on a complete cut node sequence and updates the set of top K paths. It must work on complete cut node sequences since the delays of the complete paths cannot be determined from the partial paths without fully joining them. Exemplary graph 19 (left side) in FIG. 19, shows n, as a cut vertex, and there are four subpaths illustrating overlapping subpaths due to the length constraint. If we want to filter the paths whose delays are at least 8, then only three of the four paths would be included in the answer as shown in FIG. 19 (right side). These three paths cannot be identified without fully joining the partial paths that form them.
Regarding stochastic path delays, we introduce fourth algorithm 40, shown in FIG. 4, to find the top K most critical paths in stochastic networks when the delays of the components in a circuit are given in terms of statistical parameters such as mean delays of design elements. The algorithm 40 takes into consideration the correlation among the paths. It receives expected component delays as well as covariances between the components in a circuit as input and computes two sets of path delay database: (1) the paths along with their expected delays, and (2) the paths along with their delay variances. From the variances, we approximate the standard deviations since floating point operations are not available in the VSOP tool. After that, the standard deviations and expected mean delays of paths are combined into one delay and the top K critical path delay finding algorithm is called on the combined path delays.
Fifth algorithm 50 shown in FIG. 5 calculates the approximate standard deviations (rounded to integer) from the path delay variances. At each step of the loop, algorithm 50 sets the standard deviations of the paths to i whose variances are greater than or equal to i2 but less than (i+1)2. The performance of the algorithm depends on how the path delay variances are clustered. If they are clustered around some numbers, then each step of the loop computes the standard deviations of many paths thus algorithm 50 yields to a good performance.
Like in the deterministic path delay calculation, the basic stochastic path delay calculation algorithm can cause memory overflow. In this case, we use the partition-level stochastic delay calculation algorithm (algorithm 60 shown in FIG. 6). This algorithm 60 operates like the basic stochastic delay computing algorithm. It computes the expected path delay values (Eτ), the path delay variances (Vτ), and combined path delays (Lτ) for every subgraph identified with a complete cut node sequence τ. The top K critical paths are maintained in a set (L), assuming that the top K paths are not huge. Otherwise, we should process every sequence's critical paths without maintaining them in one set.
A second application, delay-sensitive path delay implements a fault coverage calculation in which the VSOP tool is used in place of ZBDD. These new algorithms calculate the coverage metric (Eq. 16) non-enumeratively. Specifically, two algorithms are presented: (1), as shown in FIG. 7, a basic coverage calculation algorithm 70 (CoCa+), and (2), as shown in FIG. 8, a partition-based coverage calculation algorithm (PeCoCa+) 80 that overcomes the memory overflow of the basic one.
The basic Coverage Calculation algorithm 70, (1) simulates a test vector, (2) identifies the subgraph (subcircuit) detected/activated by the vector (Gi), (3) runs the VSOP based path delay finding algorithms on the subgraph (Ci, and (4) maintains the set of detected paths along with their corresponding delays (C). C.Permit (Ci) finds the intersection of C and Ci and its subtraction avoids multiple addition of the same paths to the set of detected paths. The last statement returns the number of detected paths whose delay is greater than the lower delay bound (UB).
The partition-level coverage calculation (PeCoCa+) 80 addresses issues found in the basic algorithm. The basic algorithm above may cause memory overflow during the coverage calculation of path-intensive circuits such as c6288 of ISCAS85 and b18 of ITC99. Such circuits are partitioned into subcircuits and coverage calculation is performed at the partition-level circuits. The PeCoCa is improved to a VSOP-based PeCoCa+. PeCoCa+ must compute the exact coverage by performing coverage calculations on the complete sequences, and avoid the heuristics in PeCoCa that rely on the joining of the partial paths on shorter sequences. For example, PeCoCa immediately classifies all paths passing via vertex νi as newly detected if all partial paths ending at νi are new. However, this or similar heuristics are not trivially possible when the path delays are considered. Therefore, modifications are made accordingly.
The modules of PeCoCa+ are devised in such a way that they work for deterministic as well as stochastic delay model cases. The main routine of PeCoCa+ simulates each vector, calls the cut node sequence generator (Sequences+( )). The sequence generator invokes SequenceCoverage+( ) for each activated complete cut node sequence and sums the values returned by this subroutine. A cut node sequence is activated if the currently simulated vector detects at least one path passing via the nodes in the cut node sequence. The high-level code for SequenceCoverage+( ) is included in algorithm 80. In this algorithm 80, Cτ is the set of paths along with their respective delays, which are detected by the currently simulated vector and involve only the nodes in cut node sequence τ. Vτ is the set of previously simulated vectors that detect at least one path passing through the nodes in sequence τ. PVj,τ is the set of paths along with their respective delays that are detected by a previous vector νj. The algorithm proceeds with the re-simulation of each related past vector and computation of complete paths along with their delays by calling deterministic or stochastic delay calculating function. The paths detected by the past vector v is subtracted from the set of paths detected by the current vector v. The final size of Cτ is the number of newly detected paths with respect to the cut node sequence τ whose delays are greater than or equal to the specified lower delay bound.
To achieve the experimental results we implemented most of the inventive algorithms and assessed their performances using circuit benchmarks. The first set of experiments assessed the performance of the method calculating the statistical properties/measures of circuits. The second set of experiments assessed the performances of the VSOP-based deterministic path delay computing algorithms. The third set of experiments assessed the performances of VSOP-based stochastic path delay computing algorithms. The experiments include the partition-based results as well. We approximated the performance of the path delay fault coverage calculation algorithms (CoCa+ and PeCoCa+) from the experiments instead of implementing them. All experiments were performed on an Intel-86-based 64-bit processor with two dual 2.66-GHz CPUs, and 8-Gbyte RAM with the Linux operating system.
Table 2000 shown in FIG. 20 tabulates the properties of the ISCAS85, ISCAS89 and ITC99 circuits used in our experiments. In this table, ISCAS85, combinational parts of ISCAS89, and ITC99 are given in the format of c999, cs999, and b99, respectively. For example, c880 has 60 inputs (source) and 26 output (sink) nodes, 443 gates, 729 nets (edges), and 8,642 paths.
Regarding statistical measures of path delays, in the deterministic case, we set the delays of gates to 1 uniformly in all circuits, and computed the mean (μ), standard deviation (σ), skewness (γ1), and kurtosis (γ2), of path delays along with the longest delay path (Lp·), and in each circuit. In the stochastic case, we set expected gate delays and covariances between the gate delays to 1. The results of deterministic case become the results for the expected path delays. We also report the average of path delay variances (μσ2), which takes into consideration covariances. Table 21 of FIG. 21 tabulates the results. The run times are reported under the column of Time in seconds. Furthermore, we use skewness (γ1), and kurtosis (γ2) results to test for the normality of the path delays with JarqueBera test (Eq. 14). For example, JB value for c880 is




  
    
      8642
      6
    
    ⁢
    
      (
      
        
          
            (
            
              -
              0.62
            
            )
          
          2
        
        +
        
          
            
              (
              0.53
              )
            
            2
          
          4
        
      
      )
    
  
  =
  
    654.81
    .
  




We look up this value from the Chi Square table and reject the hypothesis that the path delays come from a normal distribution. Note that we used Jarque-Bera test just to illustrate the usage of skewness and kurtosis values in normality testing.
Finally, we further assessed the performance of the moment computing algorithm by computing up to the 10th moment with a uniform cost of 2 for all gate delays. The run-time results are given in Table 22 of FIG. 22, where Time is in seconds.
The deterministic path delay results presented herein were obtained using gate delays set to a number between 1 and 10 randomly. Both basic and partition-based algorithms were evaluated with selected benchmarks and the results are given in Table 23 of FIG. 23 and Table 24 of FIG. 24, respectively. We report the number of used ZBDD nodes and computing times in seconds. The partition-based results were given for three different partitioning cases. For partition is equal to 1, we compute the path delays for every input-output pair of the circuit, rather than on the whole circuit.
With respect to stochastic path delay results, the stochastic path delay computing algorithms' results are presented. In the experiment, we assumed that the path delays are dependent. Furthermore, the expected gate delays as well as covariances between the gate delays are set to a number between 1 and 10 randomly. Both basic and partition-based algorithms were evaluated with selected benchmarks and the results are given in Table 25 of FIG. 25 and Table 26 of FIG. 26, respectively. We report the number of used ZBDD nodes and computing times in minutes:seconds format.
Regarding approximate performance of path delay fault coverage calculation algorithm, the performance results for computing the delay-sensitive path delay fault coverages are approximated from the results of deterministic and stochastic delay computing performance results. In fact, we derive upper bounds on the performance results as follows. Assuming that each test vector activates all of the paths in a circuit, CoCa+ and PeCoCa+ call the path delay computing algorithm (PathDelay( ))




  
    N
    ⁡
    
      (
      
        N
        +
        1
      
      )
    
  
  2




times, where N is the number of delay test vectors. Since the path delay fault simulation algorithm is linear with the circuit size, the performance of Pathdelay( ) dominates the run-time of the path delay fault coverage calculation algorithms. Therefore, the run-time of CoCa+ or PeCoCa+ is





  
    N
    ⁡
    
      (
      
        N
        +
        1
      
      )
    
  
  2




times the run-time of the invoked Pathdelay( ) algorithm. The memory requirement can be at most as twice as the memory requirement of Pathdelay( ) algorithm since at any time we are maintaining one set of paths for the currently simulated vector and another set for one of the previously simulated vectors.

The present invention can process large circuit sizes with thousands of nodes. Moreover, a substantially large number of paths can be stored thereby facilitating work with a large number of critical paths. The inventive path-based approach quantifies statistical measures of path delays utilizing VSOP-based algorithms.
The present invention introduces novel algorithms to compute some statistical measures and the top K most critical paths in the stochastic and deterministic timing models of (combinational) circuits. The statistical measure finding algorithm is linear with the circuit size and does not store paths or partial paths. The algorithms for finding the top K most critical paths store paths. All algorithms are non-enumerative, i.e., they don't exercise the paths one by one to find the desired outcomes.
Skilled artisans should understand that it may be possible to use the algorithm for finding the statistical measures to better approximate the statistical MAX operation. Also, there may be ways to improve the VSOP tool to handle symbolic valued sum of products instead of the currently handling of only nominal valued products.
It will be understood that the diagrams in the Figures depicting the timing verification method for stochastic networks and circuits are exemplary only, and may be embodied in a dedicated electronic device having a microprocessor, microcontroller, digital signal processor, application specific integrated circuit, field programmable gate array, any combination of the aforementioned devices, or other device that combines the functionality of the timing verification method for stochastic networks and circuits onto a single chip or multiple chips programmed to carry out the method steps described herein, or may be embodied in a general purpose computer having the appropriate peripherals attached thereto and software stored on a non-transitory computer readable media that can be loaded into main memory and executed by a processing unit to carry out the functionality of the steps of the inventive method described herein.
It is to be understood that the present invention is not limited to the embodiments described above, but encompasses any and all embodiments within the scope of the following claims.

## Claims

1. A computer-implemented timing verification method for deterministic and stochastic networks and circuits, comprising the steps of:
forming a directed acyclic graph representing portions of an electronic digital circuit having circuit elements comprised of sources and sinks, the graph having a first plurality of corresponding source and sink vertices connected by a second plurality of edges thereby creating paths which can be traversed along the directed acyclic graph;
formulating a base case using valued sums of products algebra (VSOP), the base case representing a last circuit loop which takes a union of all paths ending at the sinks;
inductively building from the base case a path database in a topological order of the circuit elements from vertices representing the source circuit elements;
performing path queries on all paths using the VSOP algebra;
wherein the path queries return a path delay timing cost for all of the electronic digital circuit; and
displaying a record verifying whether the path delay timing cost is within a margin of a specified timing performance requirement of the electronic digital circuit.

2. The computer-implemented timing verification method for deterministic and stochastic networks and circuits according to claim 1, further comprising the step of computing a sum of the kth powers of path delays, wherein the coefficient of a path is the kth power of its delay.

3. The computer-implemented timing verification method for deterministic and stochastic networks and circuits according to claim 1, further comprising the steps of:
joining all partial paths on a complete cut node sequence; and
updating a set of top K paths.

4. The computer-implemented timing verification method for deterministic and stochastic networks and circuits according to claim 3, further comprising the step of computing a coverage metric based on said set of top K paths, said coverage metric being characterized by the relation:




  
    Coverage
    
      ≥
      l
    
  
  =
  
    
      
        Detected
        ⁢
        
          
        
        ⁢
        
          paths
          
            ≥
            l
          
        
      
      
        Totalpaths
        
          ≥
          l
        
      
    
    .

5. The computer-implemented timing verification method for deterministic and stochastic networks and circuits according to claim 4, further comprising the step of computing a statistical frequency figure for a sequence of said vertices, wherein said statistical frequency figure of any given vertex of said vertices is equal to a number of incoming paths to said vertex times a number of outgoing paths from said vertex, thereby yielding a computation representing the number of paths between said vertex and all of its dependent vertices.

6. The computer-implemented timing verification method for deterministic and stochastic networks and circuits according to claim 5, further comprising the step of recursively calculating said sum of the kth powers of path delays computation.

7. The computer-implemented timing verification method for deterministic and stochastic networks and circuits according to claim 6, further comprising the steps of:
when delays of said components in said circuit are given in terms of statistical parameters, receiving expected component delays and covariances between said components in said circuit as input; and
computing two sets of path delay databases therefrom, set two sets of path delay databases being comprised of paths along with their expected delays and said same paths along with their delay variances.