EDT

(Embedded Deterministic Test)

TestKompress
Synapse DFT Overview
(A product that implements EDT)
By
Kiran K S
 AGENDA

 INTRODUCTION

 EDT ARCHITECTURE

 EXTERNAL FLOW

 INTERNAL FLOW

 EDT OPEARATION

 MASKING LOGIC

 DIFFERENT COMPRESSION

 ATPG SETUP

 CASE STUDY
 INTRODUCTION
• Embedded Deterministic Testing (EDT) is the technology used by Tessent
TestKompress.

• EDT technology is deterministic ATPG and uses the same fault models to obtain similar
test coverage , ATPG with improved compression of scan test data and a reduction in
test time.

• Tessent TestKompress achieves compression of scan test data by controlling a large

number of internal scan chains using a small number of scan channels.

Successful embedded compression is required to:

 Maintain high test quality (i.e. support all fault types)

 Achieve high test compression of both test time and test data
 Have little or no impact on the functional design
 Add minimal test logic
 Easily fit into the design flow
 Tester Time & Test Data Volume

FULLSCAN Chains: (1,667 flops)

- Chain 1 : 568 flops
- Chain 2 : 542 flops (26 lost scan shifts per vector)
- Chain 3 : 557 flops (11 lost scan shifts per vector)

COMPRESSION Chains: (max scan channel length = 568/5 = 113 flops)

- Chains 1-14: 113 flops (0 lost scan shifts per vector)
- Chain 15 : 85 flops (28 lost scan shifts per vector)

Test Time for 5,000 vectors at 20Mhz shift rate

- FULLSCAN : 568 * 50ns * 5,000 = 142 ms
- COMPRESSION : 113 * 50ns * 5,000 = 28.25 ms

Data Volume (1 bit stim, 2 bit response)

- FULLSCAN : 3 chains * 568 length * 5,000 vectors * 3 = 25.56M
o Lost data = (26+11 * 5,000) = 185K bits
- COMPRESSION : 3 chains * 113 length * 5,000 vectors * 3 = 5.085M
o Lost data = (28 * 5,000) = 140K bits
 EDT ARCHITECTURE

The embedded logic includes

Decompressor located between the external scan channel inputs and the internal scan
chain inputs
Compactor located between the internal scan chain outputs and the external scan
channel.
 EDT BLOCKS

Decompressor —The decompressor block that is inserted between the external scan
channel inputs and internal scan chain inputs consists of a ring generator and a phase
shifter

 LFSM
 Phase shifter

Compactor —The compactor resides between the core scan chain outputs and the
channel outputs connected to the tester. It primarily consists of spatial compactor(s) and
gating logic.

Bypass Module (Optional) — Bypasses the EDT logic by using multiplexers (and
lockup cells if necessary) to concatenate the internal scan chains into fewer, longer
chains. Enables you to access the internal scan chains directly through the channel pins.
Generated by default.
 Internal Diagram of DECOMPRESSOR

LFSM (Ring Generator) EDT decompressor structure where the ring generator was divided
into multiple segment

Phase Shifter:- Phase shifter connections were restricted to localized segments rather than
the entire ring generator
 LFSM & Phase Shifter

LFSM(decompressor ring generator)

 The ring generator is a unique linear finite state machine (LFSM) that is obtained by
applying a number of m -sequence preserving transformations to the canonical form

Phase Shifter

 The phase shifter logic enables the ring generator to drive the large number of internal
scan chain inputs, and reduces the linear dependencies among bit streams supplied to
the scan chain inputs by displacing them by at least the longest chain length .

 The XOR gates in the phase shifter are driven by a limited number of ring generator
stages to reduce the propagation delay.

 the XOR gates in the phase shifter can be restricted to utilize a subset of the ring
generator stages. Such modularity is helpful in significantly reducing the routing
congestion when a large number of scan chains need to be driven by the decompressor
 Internal diagram COMPACTOR

The compactor block that is inserted between the internal scan chain outputs and
external scan channel outputs is composed of XOR tree-based spatial compactors and
selective masking logic
EDT with Bypass Mode
BYPASS LOGIC
BYPASS LOGIC DIAGRAM
 EXTERNAL FLOW (EDT logic Located Outside the Core)
The External Flow is characterized by the insertion of the TestKompress logic “external” to
the top level of the functional design.

The resulting block will have a new top level named edt_top (default name) below which the
original functional core and the TestKompress logic are instantiated.

The steps in the flow are as follows:

 Prepare and synthesize the functional RTL design.

 Insert an appropriately large number of scan chains.

 Invoke TestKompress on the scan-inserted gate level netlist of the core without I/O pads
or boundary scan. Create the RTL description of the TestKompress logic.

 Insert I/O pads and boundary scan (optional step)

 Incrementally synthesize I/O pads, boundary scan and TestKompress RTL

External Flow Diagram
 INTERNAL FLOW(EDT logic Located Within the Core)
Internal Flow inserts the TestKompress logic “internal” to the top level of the functional core.
In other words a new top level of hierarchy is not created.

The steps are as follows: .

 Prepare and synthesize the functional RTL design ( including boundary scan and I/O
pads if this is the top level of the design)

 Insert an appropriately large number of scan chains.

 Invoke TestKompress on the scan-inserted gate level netlist. Specify the internal nodes
to connect to the scan chains.

 TestKompress creates the RTL description of the compression logic

 Synthesis script the tool generates will perform the TestKompress logic insertion and
connection in addition to synthesis.

 Run the synthesis script to instantiate the TestKompress logic in the top level of the
design, connect it between the design core and the top level and incrementally
synthesize the TestKompress logic. The TestKompress logic is inserted at the top level
within the original design.
Internal Flow Diagram

Internal Flow
 EDT CLOCK
The default EDT logic contains combinational logic and flip-flops. All the flip-flops, except
lockup cells, are positive edge-triggered and clocked by a dedicated clock signal that is
different from the scan clock.

There is no clock gating within the EDT logic, so it does not interfere with the system
clock(s)

Set up the clock to be a dedicated pin (named edt_clock by default) or share the clock
with a functional non-clock pin. Such sharing may cause a decrease in test coverage
because the tool constrains the clock pin during test pattern generation.

edt_clock must not share with another clock or RAM control pin for several reasons:
 EDT CLOCK Cont…

a) If shared with a scan clock, the scan cells may be disturbed when the edt_clk is pulsed in
the load_unload procedure during pattern generation.

b) If shared with RAM control signals, RAM sequential patterns and multiple load patterns
may not be applicable.

c) If shared with a non-scan clock, test coverage may decline because the edt_clk is
constrained to its off-state during the capture cycle. Because the clock used in the EDT logic
is different than the scan clock, lockup cells can be inserted automatically between the EDT
logic and the scan chains as needed.

The tool inserts lockup cells as part of the EDT logic and never modifies the design core.
 EDT UPDATE

The pin edt_update is used to reset/update two sets of registers:

 ring generator registers -- in the decompressor logic
 mask hold registers -- in the compactor logic

During the load procedure edt_update is activated. This causes the following:
ring generator registers become 0
mask_hold_register is loaded with value in the mask_shift_register

This is needed because:

ring generator needs a predictable state before generating random values, in this case all
0 is the predictable state.

mask_hold_register is designed to do per pattern masking. Each pattern has a specific

masking sequence
 EDT UPDATE Cont…
Here is what happens to the mask registers:
test_setup --- don't care

load ---- edt_update = 1, edt_clock pulses, mask_hold_register = mask_shift_register; at

this time shift register has unknown value

shift ---- pattern 1 is loaded + mask_shift_register is loaded with masking value for
pattern 1

capture -- edt_clock is off + mask_shift_register = "mask value for pattern 1" +

mask_hold_register = unknown

load ---- edt_update = 1, mask_hold_register = mask_shift_register = "mask value for

pattern 1“

shift ---- pattern 1 unloads (using mask value in mask_hold_register) + pattern 2 loads +
mask_shift_register = "mask value for pattern 2“

capture -- edt_clock is off + mask_shift_register = "mask value for pattern 2" +

mask_hold_register = "mask value for pattern 1“

load ---- edt_update = 1, mask_hold_register = mask_shift_register = mask value for

pattern 2

shift ---- pattern 2 unloads (using mask value in mask_hold_register) + pattern 3 loads +
mask_shift_register = masking value for pattern 3
 Additional shift cycles

Each compressed test pattern has a small number of additional shift cycles

Total number of shifts per pattern would be slightly more than the number of scan
cells in each chain.

The term additional shift cycles refers to the sum of the

 initialization cycles,
 masking bits (when using Xpress),
 low-power bits (when using a low-power decompressor),
 and user defined pipeline bits.
 Functional/EDT Pin Sharing
EDT pins can be shared with functional pins, with a few restrictions

EDT clock — Must be defined as a clock and constrained to its defined off state. If
shared with a bit of a bus, problems can occur during synthesis. For example, Design
Compiler (DC) does not accept a bit of a bus being a clock.

The EDT clock pin must only be shared with a non-clock pin that does not disturb scan
cells; otherwise, the scan cells will be disturbed during the load_unload procedure when
the EDT clock is pulsed.

This restriction might cause some reduced coverage. You should use a dedicated pin for
the EDT clock or share the EDT clock pin only with a functional pin that controls a small
amount of logic. If any loss of coverage is not acceptable, then you must use a dedicated
pin.

EDT update — Can be shared with any non-clock pin. Because the EDT update pin is
not constrained, sharing it has no impact on test coverage.

Bypass (optional) — Must be forced during scan (forced on in the bypass test
procedures and forced off in the EDT test procedures). It is not constrained, so sharing it
has no impact on test coverage.
 Internally Driven EDT Pins
When an EDT control pin is driven internally by JTAG or other control registers, should use
the set_edt_pins command to specify that no top-level pin exists for the control pin .
 EDT OPERATION

Prior to each scan load, the EDT logic needs to be reset. This is done by pulsing the EDT
clock once while EDT update is high

During shifting, the EDT clock should be pulsed together with the scan clock(s).

Both scan enable and EDT update are shown as 0 during the capture cycle. These two
signals can have any value during capture; they do not have to be constrained.

On the other hand, the EDT clock must be 0 during the capture cycle.
EDT Waveform
 Design Rules Checking (DRC)

 The tool provides the most complete information about violations of these rules when
you have preserved the EDT logic structure through synthesis. Following is a brief
summary of just the K rules that verify operation of the EDT logic:

 K19 — simulates the decompressor netlist and performs diagnostic checks if a

simulation-emulation mismatch occurs.

 K20 — identifies the number of pipeline stages within the compactors, based on
simulation.

 K22 — simulates the compactor netlist and performs diagnostic checks if a simulation
emulation mismatch occurs.
 EDT Logic and Chain

This equation, ceil indicates the ceiling function that rounds a fraction to the
next highest integer.)

 Currently there is no control for the number of patterns saved. The reason is that
these patterns not only test the chain but also the EDT logic.

 The reason for all the patterns is that these represent combinations of masking
states and paths that are needed to observe the individual chain integrity.

 Basically the chain observation must go though the decompressor and compressor
logic. So it is not useful to abbreviate the number of patterns for the chain test. If only a
few are tested and they pass there could still be other combinations that fail. Yes, the edt
logic is tested with the chain test pattern set.
 This test consists of several scan patterns that verify correct operation of the EDT
logic and the scan chains when faults are added on the core or on the entire design. This
test is necessary because the EDT logic is not the standard scan-based circuitry that
traditional chain test patterns are designed for..
 EDT Logic and Chain Cont..

Coverage for EDT Logic and Chain Test

 EDT chain test does not test the bypass mode input of each bypass multiplexer
(edt_bypass is kept constant in EDT mode during the chain test).

 The size of the chain test pattern set depends on the configuration of the EDT logic and
the specific design. Typically, about 18 chain test patterns are required when you
approach 10X compression.

 The EDT logic and chain test helps in debugging simulation mismatches and guarantees
very high test coverage of the EDT logic

 TestKompress saves an EDT logic and chain test as part of the pattern set
EDT Logic with Power Controller
 LOW POWER OPERATION

 When using the low power decompressor, an extra setup pattern is added.
This setup pattern is tagged/commented as a "edt_setup" pattern file.

 This initialization pattern will initialize the low power mask register. The low
power mask register selects what chains will be loaded with a constant zero
during shift. The initialization pattern will load the low power mask register
with the correct value for the first pattern load.

 The pattern involves one scan chain load and by default all chains will be
loaded with constant 0 to minimize switching activity.
Basic Compactor Architecture

Block diagram of Basic Compactor

 Basic Compactor Operation

 A mask code (prepended with a decoder mode bit) is generated with each
test pattern to determine which scan chains are masked or observed. The
basic compactor determines which chains to observe or mask using the
mask code as follows:

 The decompressor loads the mask code into the mask shift register.

 The mask code is parallel-loaded into the mask hold register, where the
decoder mode bit determines the observe mode: either one scan chain or
all scan chains.

 The mask code in the mask hold register is decoded and each bit drives
one input of a masking AND gate in the compactor. Depending on the
observe mode, the output of these AND gates is either enabled or
disabled.
Xpress Compactor Architecture

Block diagram of Xpress Compactor

 Xpress Compactor OPERATION

A mask code (prepended with a decoder mode bit) is generated with each test pattern to
determine which scan chains are masked or observed. The Xpress compactor determines
which chains to observe or mask using the mask code as follows:

 Each test pattern is loaded into the decompressor through a mask shift register on the
input channel.
 The mask code is appended to each test pattern and remains in the mask shift register
once the test pattern is completely loaded into the decompressor.
 The mask code is then parallel-loaded into the mask hold register, where the decoder
mode bit determines whether the basic decoder or the XOR decoder is used on the mask
code.
 The basic decoder selects only one scan chain per compactor. The basic decoder is
selected when there is a very high rate of X values during scan testing or during chain
test to allow failing chains to be fully observed and easy to diagnose.
 The XOR decoder masks or observes multiple scan chains per compactor, depending
on the mask code. For example, if the mask code is all 1s, then all the scan chains
are observed.
 The decoder output is shifted through a multiplexer, and each bit drives one input on the
masking AND gates in the compactor to either disable or enable the output, depending on
the decoder mode and bit value.
BASIC COMPACTOR MASKING LOGIC
 DECODER CIRCUIT

 Example Decoder Circuitry for Six Scan Chains and One Channel
 Understanding Scan Chain Masking in the Compactor

Why Masking is Needed

One common problem with different compactor strategies is handling of Xs (unknown values).
Scan cells can capture X values from unmodeled blocks, memories, non-scan cells, and
so forth.

Assume two scan chains are compacted into one channel.

An X captured in Chain 1 will then block the corresponding cell in Chain 2. If this X occurs in
Chain 1 for all patterns, the value in the corresponding cell in Chain 2 will never be measured.
This is illustrated in Figure where the row in the middle shows the values measured on the
channel output

The tool records an X in the pattern file in every position made unmeasurable as a result of
the actual occurrence of an X in the corresponding cell of a different scan chain in the same
compactor group. This is referred to as X blocking.

The capture data for Chain 1 and Chain 2 that you would see in the ASCII pattern file for this
example would look similar to Figure.

The Xs substituted by the tool for actual values, unmeasurable because of the compactor, are
shown in red.
 Scan Chain Masking Logic cont …

X-Blocking in the Compactor

X Substitution for Unmeasurable Values

 Resolving X Blocking with Scan Chain Masking
The solution to this problem is a mechanism utilized in the EDT logic called “scan chain
masking.” This mechanism allows selection of individual scan chains on a per-pattern
basis.

Two types of scan chain masking are used:

 1-hot masking
 flexible masking.

With 1-hot masking, only one chain is observed via each scan channel's compaction
network.

All the other chains in that compactor are masked so they produce a constant 0 to the
input of the compactor. This allows observation of fault effects for the observed chains
even if there are Xs in the observation cycles for the other chains.

1-hot masking patterns are only generated for a few ATPG cycles at points when the
non-masking and flexible masking algorithms fail to detect any significant number of
faults.
 Resolving X Blocking Cont…
Flexible masking patterns allow multiple chains to be observed via each scan channel's
compaction network.

Flexible masking is not fully non-masking; with fully nonmasking patterns, none of the chains
are masked so Xs in some cycles of some chains can block the observation of the fault effects
in some other chain.

The Xpress compactor observes all chains with known values and masks out those scan
chains that contain X values so they do not block observation of other chains.
With Xpress flexible masking, only a subset of the chains is masked to maximize the fault
detection profile while reducing the impact on pattern count.
When a fault effect cannot be observed at the channel output under any of the flexible
masking configurations, the tool uses 1-hot masking to guarantee the detection of such faults
.
Figure shows how scan chain masking would work for the example of the preceding section.
For one pattern, only the values of Chain 2 are measured on the scan channel output. This
way, the Xs in Chain 1 will not block values in Chain 2. Similar patterns would then also be
produced where Chain 2 is disabled while the values of Chain 1 are observed on the scan
channel output
 X Blocking with Scan Chain Masking

Example of Scan Chain Masking

Handling of Scan Chain Masking

 X Blocking with Scan Chain Masking Cont…

When using scan chain masking, the tool records the actual measured value for each cell in
the unmasked, selected scan chain in a compactor group. The tool masks the rest of the
scan chains in the group, which means the tool changes the values to all Xs.

With masking, the capture data for Chain 1 and Chain 2 that you would see in the ASCII
pattern file would look similar to Figure 8-30, assuming Chain 2 is to be observed and Chain
1 is masked. The values the tool changed to X for the masked chain are shown in red.
 Top Level TestKompress
 For small to medium sized designs that are synthesized as a single entity or physically
laid out as a single entity, it makes sense to implement a single Decompressor and
Compactor at the top level of the design

The Top Level implementation is best suited for:

 - Small to medium sized designs in which synthesis and/or physical design is
performed on a single entity.

Block diagram of Top Level TESTKOMPRESS

 Block-Based - Modular
 Large SOC designs requires that both synthesis and physical design are done at the
block level. The resulting “hardmac” blocks are then assembled together at the top level.

 For these cases the best implementation is to design TestKompress into each hardmac
block which is commonly referred to as Modular TestKompress.

 Even for those block-based design flows that allow top level logic, putting TestKompress
into the block level is best. It will avoid any potential routing congestion at the top level
that could result from trying to route a single Decompressor and Compactor to
potentially several hundred internal scan chains across the die.

The Block-Based – Modular approach is best suited for:

 Large SOC designs synthesized and laid out at the block level
 Designs that anticipate top level routing congestion
 Designs that do not allow logic at the top level
 Designs that do not anticipate power problems during test therefore it is safe to
generate patterns on the entire chip
 Block-Based – Modular Diagram

Block Based TestKompress w/Top Level Block Based TestKompress – No Top Level
Logic Logic
 Creation of EDT Logic Files

 created_edt_top.v (external EDT logic only) — Top-level wrapper that instantiates the
core, EDT logic circuitry, and channel output sharing multiplexers.
 created_edt_top_rtl.v (internal EDT logic only) — Core netlist with an instance of the
EDT logic connected between I/O pads and internal scan chains but without a gate-level
 description of the EDT logic.
 created_edt.v — EDT logic description in RTL.
 created_core_blackbox.v (external EDT logic only) — Blackbox description of the
core for synthesis.
 created_dc_script.scr — DC synthesis script for the EDT logic.
 created_rtlc_script.scr — RTL Compiler synthesis script for the EDT logic.
 created_edt.dofile — Dofile for test pattern generation.
 created_edt.testproc— Test procedure file for test pattern generation.
 created_bypass.dofile — Dofile for uncompressed test patterns (bypass mode)
 created_bypass.testproc— Test procedure file for uncompressed test patterns
(bypass mode)
 ATPG(Test Procedure)
set time scale 1.000000 ns ; procedure shift =
set strobe_window time 100 ; scan_group grp1 ;
timeplate gen_tp1 ;
timeplate gen_tp1 = cycle =
force_pi 0 ; force_sci ;
measure_po 100 ; force edt_update 0 ;
pulse clk 200 100; measure_sco ;
pulse edt_clock 200 100; pulse clk ;
pulse ramclk 200 100; pulse edt_clock ;
period 400 ; end;
end; end;

procedure capture =
timeplate gen_tp1 ;
cycle =
force_pi ;
measure_po ;
pulse_capture_clock ;
end;
end;
 ATPG (Test Procedure) Cont…

procedure load_unload = procedure test_setup =

scan_group grp1 ; timeplate gen_tp1 ;
timeplate gen_tp1 ; cycle =
cycle = force edt_clock 0 ;
force clk 0 ; end;
force edt_bypass 0 ; end
force edt_clock 0 ;
force edt_update 1 ;
force ramclk 0 ;
force scan_en 1 ;
pulse edt_clock ;
end ;
apply shift 26;
end;
 CASE STUDY
Design Specification:-

Technology :- 40nm
Compression :- Two EDT Blocks
Scan Channel :- 10 channels(5+5)
Internal Chains :- 385 Chains
Flop Count :- ~265000 Flop Count
TestClocks :- 3 Clocks
Maximum Frequency :- 400MHz

TOOL Flow :-
SCAN INSERTION :- Design Compiler
COMPRESSION :- TESTKOMPRESS
ATPG :- TESTKOMPRESS

Approach :
TOP DOWN Approach
Netlist Based EDT insertion
 SCAN & COMPRESSION INSERTION FLOW
 STEP1 :- Scan Insertion
 Input :-
 Synthesis Netlist
 Scan insertion Tcl file( DC commands)
 Output :-
 Scan inserted netlist ( Maximum number scan chains based on
compression Ratio)
 SPF file (Still file)
 STEP2 :- Synopsys SPF to Mentor TestProc and Dofile
/sw/mentor/tessent/2012.2/bin/stil2mgc -stil dft_top.spf -TPf dft_top.testproc -DOfile
dft_top.dofile -log mgc.log –replace
Input :- setup.txt (It Contains Test Programming Information)
output:- setup.txt.mtr
Run:- SPItoMentor.pl setup.txt
Copy the SPI test program setup (test_setup ) From shortbread_setup.txt.mtr to the
Testproc file
dft_top.dofile :- Contains Clocks information's, ATPG constraints and Scan chain
informations
dft_top.testproc :- Contains test_setup, shift, capture, load_unload procedures
 SCAN & COMPRESSION INSERTION FLOW Cont ..
STEP 3:- EDT RTL CREATION
copy the generated testproc and dofile from step2
Input :-
 edtc.netlist includes netlist dft_top.PostSCANI.v and *_tmax.v's
 dft_top.testproc
 dft_top.dofile
 mgc.lib :- includes library *.atpg files
Output :-
 EDT Inserted RTL :- dft_top_edt.v
 DC script for EDT Synthesis dft_top_dc_script.scr
 dft_top_edt_RTL.v ( Scan synthesis netlist with EDT instantiation)
 ATPG dofiles & testproc files(Compression & Bypass)

STEP4 :- EDT SYNTHESIS

Input :-
 EDT Generated RTL from Step3 dft_top_edt.v
Intermediate Output:-
 dft_top_edt_gate.v
Output :-
 EDT Inserted Synthesized Netlist ( Concatenation of Synthesis EDT inserted RTL
dft_top_edt_top_rtl.v from STEP3 and Synthesized EDT RTL dft_top_edt_gate.v)