- 54 Views
- Uploaded on
- Presentation posted in: General

Efficient SAT-based Combinational ATPG using Multi-level Don't-Cares

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Efficient SAT-based Combinational ATPG using Multi-level Don't-Cares

Nikhil Saluja

Department of ECE, University of ColoradoBoulder, CO

Sunil P KhatriDepartment of ECE, Texas A&M UniversityCollege Station, TX

- Motivation and Introduction
- Boolean SATisfiability (SAT)
- Compatible Observability Don't Cares (CODCs)
- SAT based ATPG
- Approximate CODC-enhanced SAT based ATPG
- Modified Fault Propagation Clauses
- Modified Fault Justification Clauses

- Results
- Conclusions, Future Work

- Manufacturing defects manifest as logical faults. Modeled as stuck-at-0 or stuck-at-1 faults.
- ATPG algorithms determine tests, assuming a single-stuck fault model
- Three broad classes of ATPG algorithms
- Structural - perform topological search based on circuit structure
- Algebraic - manipulation of formulas which express the tests for a fault
- Hybrid - SAT based ATPG falls in this class

- References for each category mentioned in paper

- The Boolean difference of f w.r.t x is defined as
- The test for a node x stuck-at-0 is defined as
where f is some primary output of the multi-level Boolean circuit.

- The first term is the fault excitation / justificationcondition. The second term is the fault propagation condition.

- A conjunctive normal form(CNF) Boolean formula f on n Boolean variables {x1,x2,...,xn} is a conjunction (logical AND) of m clauses {c1,c2,...,cm}. Each clause ci is the disjunction (logical OR) of its constituent literals.
- Example f = (x1 + x3).(!x1 + !x2 + !x3)

- Boolean satisfiability (SAT) is the problem of determining whether a Boolean formula in conjunctive normal form (CNF) has a satisfying assignment.
- A satisfying assignment for f is x1 = 1, x2 = 0.

- A SAT solver may return one of three conditions.
- Not satisfiable (solver mentions this)
- Satisfiable (solver returns a satisfying solution)
- Unknown (solver timed out).

- SAT is the classic NP complete problem
- Several efficient heuristic SAT solvers
- GRASP, based on non-chronological backtrack
- Zchaff, based on ''2-watched'' literals
- CirCUs, BerkMin and others which still use the non-chronological backtrack idea of GRASP

- The Observability Don't Care of node yj with respect to output zk (ODCjk) is the set of minterms for which the value of yj is not observable at zk. Can be denoted as:
- Modifying a node by minimizing it w.r.t its ODC results in a change in the ODCs of other nodes.
- This motivated Compatible ODCs (CODCs).
- Can simultaneously modify all nodes as long as each modified function is contained in its CODC

- If zk explicitly depends on yj (i.e. yj is a fanin of zk), can be computed using the Boolean difference formula.
- Otherwise, we use the chain rule:

- For the good circuit, write CNF formulae for all gates
- For a 2-input AND gate z = x AND y,
(!z + x).(!z + y).(z + !x + !y)

- For a 2-input AND gate z = x AND y,
- For the faulty circuit, write CNF formulae for gates in the TFO of the fault
- Fault detection clauses consist of the logical OR of clauses which are the XOR of good and faulty circuit outputs.
- Solve this using a SAT solver. If a satisfying solution exists, then it is a test.
- Active clauses used to speed up the process.

- Larrabee's SAT approach utilized active clauses in the TFO of the fault site.
- Each node in the fault’s TFO has an active variable.
- A node x is active (represented as xa) if its value in the good ckt is different from its value in the faulty ckt.
- (!xa + x + xf).(!xa + !x + !xf)
- If a node is active then at least one of its fanouts must be active. Also, one of the outputs must be active
- SAT based ATPG has no notion of circuit structure. So, these active clauses provide useful structural guidance to the search.
- Correctness is not compromised if active clauses omitted

- Part 1: Faster fault propagation
- If the input assignment of a node is contained in its CODC, the node cannot be active.
- This avoids unnecessary search.
- xa => !(CODCx)
- Correctness is not compromised if
- Some or all active clauses are omitted.
- A subset of the CODC is used in the above equation.
- We utilize Approximate CODCs instead of CODCs
- We delete ACODC clauses with k+1 or more literals

- Average improvement of 41.5% in ATPG runtime with these clauses (4% clause overhead)

- Part 2: Faster fault justification
- Node x is a dominator of node y if all paths from y to the POs go through x.
- Find all nodes in the TFI of the fault (except PIs) for which the fault site is a dominator.
- Assign new j-active variables to such nodes. The chain rule now reduces to:
- Here zk is a primary output, g1 is the fault node and yj is a node which is dominated by g1.

- First term is the care-set for fault propagation.
- Second term is the care-set for fault justification.
- In other words, the care points used for the node yj are those obtained by computing
- In practice, we compute the care points for node yj as !(CODCj), since these have already been computed during technology-independent logic optimization.

- If a node p is j-active then its input assignment must not be contained in its CODC. Hence:
Pj-active => !(CODCp)

- CODCs computed using an ROBDD computation. Limited to circuits with few thousand gates.
- Recently, we developed an Approximate CODC technique which:
- Can be computed for arbitrarily large circuits
- Results in runtimes and memory utilization of about 30X lower than CODC computation
- Literal count reduction is about 80% of that of CODCs

- We utilize ACODCs in our SAT based ATPG algorithm, allowing it to be applicable to large designs.

- Scatter plot of run-times for old method versus ours
- Our method performs better for larger examples

ACODCs

- Note low clause and variable overheads for methods (1) and (2)
- The use of ACODCs reduces this slightly, compared to CODCs

- Large examples - CODCs can’t be computed, so ACODCs used
- Low clause and variable overheads for both methods.
- Runtimes are about 0.69X those of commercial ATPG
- Commercial ATPG aborts a few faults, our method does not.

- Formulated CODC-enhanced SAT based ATPG
- Clauses to speed up fault propagation
- Clauses to speed up fault justification

- Formulation is general
- Can utilize Approximate CODCs
- Correctness not compromised if some literals in our clauses are left out
- Correctness not compromised if some nodes are left out

- Results demonstrate 31% speedup over a commercial ATPG tool for large designs

Thanks for

your attention!!