Algorithme de test de mémoires pour « Neighborhood Pattern sensitive Faults »

Andrey GonzalezNegin Sahraii

Test de systèmes ÉlectroniquesELE6306

Introduction

• NPSF important pour tester DRAMs.

• NPSF exige un temps de test long (plus de 100N opérations de lecture/écriture) où N est la taille de l’adresse.

•Il y a différentes sortes de test pour NPSF mais avec un bas taux de couverture.

•La méthode MARCH traditionnel a un bon taux de couverture mais il ne détecte pas tous les NPFS.

•La méthode MARCH en utilisant Backgrounds multiples est proposée [1].Cette méthode détecte statique NPSF, passive NPFS et active NPFS

•Avantages: Temps de test plus court, taux de couverture complet pour NPSF, facile implémentation BIST

[1] K.Cheng, M. Tsai et C. Wu. Université National Tsing Hu

Model de fautes NPFS

• Un “Neighborhood pattern sensitive fault” arrive lorsque le contenu d’une cellule de la mémoire ou la capacité de changement de la cellule est influencé par certain pattern d’autres cellules voisines dans la mémoire.

•NPFS Statique (SNPSF): Il arrive si la cellule de base est forcé à certain état en raison de l’apparition de certain pattern dans les cellules voisines.

•NPFS Passif (PNPSF): Il arrive si la cellule de base ne peut pas changer de l’état 0 à 1 ou 1 à 0 en raison de l’apparition de certain pattern dans les cellules voisines.

•NPFS Actif (ANPSF): Il arrive si la cellule de base est forcé à certain état lorsque un transition arrive dans un seule cellule voisine tandis les autres cellules voisines prendre un certain pattern .

Model de fautes NPFS

Algorithme March

•Les algorithmes MARCH Traditionnelles couvrent un petit pourcentage des NPSFs.

•Lorsque on lit ou écrit la cellule base (B), toutes le cellules avec adresse plus haute que B ont le même état. La même chose arrive avec les cellules avec adresse plus basse que B. Exemple:

•La majeure partie des NPSFs ne peut pas être activé par le test MARCH.

•Le TC est plus petit que 30% si l’algorithme MARCH utilise seulement backgrounds de données solides.

Algorithme March

•Si on utilise backgrounds de données multiples, tous les patterns peuvent être générés. Exemple:

•Dans la figure, a est le contenu de la cellule et b est le complément de cet valeur.

Algorithme March avec 8 Backgrounds

•On a besoin d’un générateur de background pour remplir la mémoire avec les bits correspondant. Le bit a est généré par l’adresse de lignes et de colonne de la mémoire.

•Algorithme MARCH-12N:•{ (wa); (ra,wb,wa); (ra,wb); (rb,wa,wb); (rb,wa); (ra)}.

•Cet algorithme est complet. Il détecte tous les NPSFs avec un temps de test de 96N (12x8N).

Algorithme March avec 8 Backgrounds

La figure suivant montre les ANPSFs qui sont détectés avec l’algorithme MARCH-12N avec les 8 backgrounds:

Algorithme March avec 8 Backgrounds

•Si on veut couvrir les fautes AF et CFst, on ajoute 4N opérations à MARCH-12 seulement pour le background 1:

•Background 1 prolongé à 16N operations:

{ (wa); (ra,wb,wa); (ra,wb); (rb,wa,wb); (rb,wa); (ra,wb); (rb,wa); (ra)}.

•Toutes les fautes sont couvertes avec cet “extended 12N MARCH”. L’algorithm resultant 100N (16 + 12x7).

Conception BIST

[2] M.Bushnell, V.Agrawal. Essentials of Electronics Testing

Comparator

Ram Pulse

Generator

UP/Down Counter

Background pattern Generator

BIST Controller(State machin)

RAM

Buffer

Le circuit de BIST

Datain

writ

cle

ar

cou

nt

last

ad

first

ad

fina

error

coun

tup

add(0-14)

test

wr_

n

oe

_

cs

writdatab

data

add0,add1,add6

315

oe_nrst_n

clk

rst_n

bgfbgc

test

syserrorsyscorrect

test

Conception BIST

Conception BIST

Signaltesterrorfinabgfbgcdatainfirstaddlastaddcountupcountclear Si '1', 'counter' recommence la compte (première adresse de mémoire)writesyserrorsyscorrectdatab

csoe_nwr_n

signification

BG2 et les états(wa ou ra) : add6+add0 BG2 et les états(wb ou rb): not(add6+add0)

BG7 et les états(wa ou ra): add0+add1 BG7 et les états(wb ou rb): not(add0+add1)

Si '1', 'counter' compte

Dans le dernier état de l'algorithme pour chaque Background, il devient '1'

Pendent les états wa et ra, il devient '0' et pendent les états wb et rb, il devient '1'

Si '1', pulse we_n actif, si '0', pulse oe_n actif

BG6 et les états(wa ou ra): add1+add6 BG1 et les états(wb ou rb):not(add1+add6)

si test=0 : oe_n='Z', si test=1 et write=0 : oe_n=not(clk), si test=1 et write=1 :oe_n='1'si test=0 : wr_n='Z', si test=1 et write=1 : wr_n=not(clk), si test=1 et write=0 :wr_n='1'

si '1' le contrôleur BIST commence à tester la RAMsi datab#data et oe_n ='0' ,error= '1' ,sinon error= '0'

Quand background=1, bgc= '1'Quand background=8, bgf = '1'

Quand add="000000000000001",il devient 1Quand add="111111111111110",il devient 1

BG3 et les états(wa ou ra): add6 BG1 et les états(wb ou rb): not add6

BG5 et les états(wa ou ra): add1 BG5 et les états(wb ou rb): not add1BG4 et les états(wa ou ra): add0 BG4 et les états(wb ou rb): not add0

BG8 et les états(wa ou ra):add6+add0+add1 BG8 et états(wb ou rb):not(add6+add0+add1)Si test=1 :cs= '0', sinon :cs=' Z'

Quand une erreur est détecte, syserror= '1'Quand le processus de l'algorithme termine sans erreur, syscorrect= '1'BG1 et les états(wa ou ra): '0' BG1 et les états(wb ou rb): '1'

Si '1', 'counter' incrémente l'adresse, sinon 'counter' décrémente l'adresse

start m0waa

m0wa

m1ra

m1wa

m1wb

m1wbb

m1raa

m1waa

m2raa

m2ra

m2wb

m3wa

m2wbb

m3rbb

m3waa

m3wbb

m3wb

m3rb

m4waa

m4rbb

m4rb

m4wa

m5ra

m5wb

m5raa

m5wbb

m6rb

m6wa

m6waa

m6rbb

m7ra

m7raa

correct

error

test=0

test=1

lastadd=0

bgc=1

lastadd=1

lastadd=0

lastadd=1

lastadd=1

lastadd=1

lastadd=1

lastadd=0

lastadd=0

lastadd=0

lastadd=0

lastadd=1

error=1

firstadd=1 firstadd=0

firstadd=0

firstadd=1

error=1

error=1

error=1

error=1

error=1

bgc=0

bgf=1

bgf=0

s0s6 s8

s10

s3s1 s2

s9

s7s4 s5

s13

s11s12

s14s15

s19s20s21

s18 s17 s16

s23s24

s22

s25s26

s30 s29 s27

s34

s28

s31s32s33

Machine à état du contrôleur BIST:

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 340 0 0 0 1 0 0 1 0 0 1 0 1 1 0 1 1 0 1 1 0 1 0 0 1 0 1 1 1 1 0 0 0 0 01 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 0 01 1 1 0 0 1 0 0 1 0 1 0 0 0 0 1 0 0 1 0 1 0 0 0 1 0 0 0 0 0 1 1 0 0 01 1 1 0 1 1 0 1 1 0 1 0 1 0 1 1 0 1 1 0 1 0 1 0 1 0 1 0 0 0 1 0 0 0 00 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 10 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 00 1 0 1 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 1 0 0 00 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0fina

Les signaux de sortie du contrôleur BIST

writesyserror

syscorrectclear

dataincountup

count

étatsignal

Modèle de Faute NPSF 

• Ram (32K x 1bit) contient 64 ‘columns’ et 512‘rows’.

•Adresse de cellule défectueuse est «addbase ».

•Cellules voisines:adresse (N) = addbase-64, adresse (W) : addbase-1, adresse ( E )= addbase+1, adresse ( S) =addbase+64.

Modèle de Faute NPSF Statique 

-- Modèle de faute NPSF Statique (“NEWS”<=”1001”) => (B<=’0’):

If(WE’event AND WE=’1’) then Memory(conv_integer(Address) ) :=Data ;End if; If(Address = addbase and Memory(conv_integer(addbase-64))=’1’ and Memory(conv_integer(addbase-1))=’0’ and Memory(conv_integer(addbase+1))=’0’ and Memory(conv_integer(addbase+64))=’1’ ) then Memory(conv_integer(addbase))=’0’; End if;

Modèle de Faute NPSF Passif

--Modèle de faute NPSF passif (“NEWS”<=”1010”) => (Base ne peux pas changer):

If(WE’event AND WE=’1’) then If (change =’0’ )then Memory(conv_integer(Address) ) :=Data ; End if; End if; If(Address = addbase and Memory(conv_integer(addbase-64))=’1’ and Memory(conv_integer(addbase-1))=’0’ and Memory(conv_integer(addbase+64))=’1’ and Memory(conv_integer(addbase+1))=’0’ ) then Change <=’1’ ; else; Change <=’0’ ; End if;

Modèle de Faute NPSF Actif

--Modèle de faute NPSF Actif (“NEWS”<=”01↑1”) => (B<= ‘0’):

If(WE’event AND WE=’1’) then If(Address = addbase+1) then If (Memory(conv_integer(addbase-64))=’1’ and

Memory(conv_integer(addbase-1))=’1’ and Memory(conv_integer(addbase+64))=’1’ and

Data =’1’ and Memory(conv_integer(addbase+1))=’0’ ) then Memory(conv_integer(addbase)) :=’0’ ; End if; End if; Memory(conv_integer(Address) ) :=Data ; End if;

Résultat de la simulation sans fautes

Résultat de la simulation avec NPSF  Statique

Résultat de la simulation avec NPSF  Passif

Résultat de la simulation avec NPSF  Actif

Conclusions

•La méthode MARCH traditionnel a été améliorée en utilisant des Backgrounds multiples.

•L’algorithme MARCH-12 N prolongé peut détecter tous les NPSFs, CF et AF.

•Temps de test 100N bas en relation au nombre de fautes détectés

•Un Algorithme de diagnostic peut être implémenté pour détecter le type et l’endroit de la faute détecté en utilisant signatures MARCH.