efficient sat based combinational atpg using multi level don t cares
Skip this Video
Download Presentation
Efficient SAT-based Combinational ATPG using Multi-level Don\'t-Cares

Loading in 2 Seconds...

play fullscreen
1 / 19

Efficient SAT-based Combinational ATPG using Multi-level Dont-Cares - PowerPoint PPT Presentation

  • Uploaded on

Efficient SAT-based Combinational ATPG using Multi-level Don\'t-Cares. Nikhil Saluja Department of ECE, University of Colorado Boulder, CO Sunil P Khatri Department of ECE, Texas A&M University College Station, TX. Outline. Motivation and Introduction Boolean SATisfiability (SAT)

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about 'Efficient SAT-based Combinational ATPG using Multi-level Dont-Cares' - hung

An Image/Link below is provided (as is) to download presentation

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 - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
efficient sat based combinational atpg using multi level don t cares

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
motivation and introduction
Motivation and Introduction
  • 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.
boolean satisfiability
Boolean SATisfiability
  • 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.
boolean satisfiability 2
Boolean SATisfiability … 2
  • 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
compatible observability don t cares
Compatible Observability Don’t Cares
  • 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
boolean differences
Boolean Differences
  • 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:
sat based atpg
SAT based ATPG
  • 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 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.
sat based atpg 2
SAT based ATPG … 2
  • 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
codc enhanced sat based atpg
CODC-enhanced SAT based ATPG
  • 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)
codc enhanced sat based atpg 2
CODC-enhanced SAT based ATPG … 2
  • 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.
codc enhanced sat based atpg 3
CODC-enhanced SAT based ATPG … 3
  • 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)

codc enhanced sat based atpg 4
CODC-enhanced SAT based ATPG … 4
  • 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.
experimental results
Experimental Results
  • Scatter plot of run-times for old method versus ours
  • Our method performs better for larger examples
experimental results1


Experimental Results
  • Note low clause and variable overheads for methods (1) and (2)
  • The use of ACODCs reduces this slightly, compared to CODCs
experimental results2
Experimental Results
  • 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.
conclusions and future work
Conclusions and Future Work
  • 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!!