Efficient sat based combinational atpg using multi level don t cares
This presentation is the property of its rightful owner.
Sponsored Links
1 / 19

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


  • 41 Views
  • Uploaded on
  • Presentation posted in: General

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)

Download Presentation

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

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


Outline

Outline

  • 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


Preliminaries

Preliminaries

  • 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

ACODCs

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


Efficient sat based combinational atpg using multi level dont cares

Thanks for

your attention!!


  • Login