Présentation

Algorithme de test de mémoires pour «
Neighborhood Pattern sensitive Faults »
Test de systèmes Électroniques
ELE6306
Andrey Gonzalez
Negin Sahraii
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
Conception BIST
test
wr_n
count
clear
add(0-14)
UP/Down
Counter
RAM
15
3
Datain
bgc
fina
bgf
add0,add1,add6
Background
pattern Generator
writ test
datab
Buffer
rst_n oe_n
error
Comparator
Le circuit de BIST
cs
writ
Ram Pulse
Generator
countup
firstad
lastad
BIST Controller
(State machin)
rst_n
syserror
syscorrect
clk
oe_
test
data
Conception BIST
Signal
test
error
fina
bgf
bgc
datain
firstadd
lastadd
countup
count
clear
write
syserror
syscorrect
datab
cs
oe_n
wr_n
signification
si '1' le contrôleur BIST commence à tester la RAM
si datab#data et oe_n ='0' ,error= '1' ,sinon error= '0'
Dans le dernier état de l'algorithme pour chaque Background, il devient '1'
Quand background=8, bgf = '1'
Quand background=1, bgc= '1'
Pendent les états wa et ra, il devient '0' et pendent les états wb et rb, il devient '1'
Quand add="000000000000001",il devient 1
Quand add="111111111111110",il devient 1
Si '1', 'counter' incrémente l'adresse, sinon 'counter' décrémente l'adresse
Si '1', 'counter' compte
Si '1', 'counter' recommence la compte (première adresse de mémoire)
Si '1', pulse we_n actif, si '0', pulse oe_n actif
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'
BG2 et les états(wa ou ra) : add6+add0 BG2 et les états(wb ou rb): not(add6+add0)
BG3 et les états(wa ou ra): add6
BG1 et les états(wb ou rb): not add6
BG4 et les états(wa ou ra): add0
BG4 et les états(wb ou rb): not add0
BG5 et les états(wa ou ra): add1
BG5 et les états(wb ou rb): not add1
BG6 et les états(wa ou ra): add1+add6 BG1 et les états(wb ou rb):not(add1+add6)
BG7 et les états(wa ou ra): add0+add1 BG7 et les états(wb ou rb): not(add0+add1)
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'
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'
s1
s0
test=1
start
m0
wa
last
add=1
s2
s3
last
s6
add=1
m1
raa
s5
s4
m1
wb
m1
ra
m0
waa
m1
wa
s7
s8
m1
waa
m1
wbb
lastadd=0
test=0
error=1
lastadd=0
last
s10
m2 add=1 m2
wb
raa
s12
s9
s11
m2
wbb
m2
ra
lastadd=0
error=1
s18
s15
s16
s17
m3
rbb
m3
waa
m3
wbb
last
add=1
s14
lastadd=0
s34
Machine à état du
contrôleur BIST:
error=1
error
m4
waa
s22
s21
m4
rbb
last
add=1
m4
wa
s19
s20
m4
rb
lastadd=0
error=1
m5
raa
s23
s24
s25
s26
m5
wbb
first
add=1
m5
wb
m5
ra
bgc=1
firstadd=0
error=1
error=1
s27
s28
s29
s30
m6
waa
m6
m6
rbb first
wa
add=1
firstadd=0
m6
rb
lastadd=0
s32
s33
correct
bgf=1
m7
raa
last
add=1
m7
ra
s31
bgf=0
Les signaux de sortie du contrôleur BIST
état
signal
datain
countup
count
write
syserror
syscorrect
clear
fina
0
0
1
1
1
0
0
0
0
1
0
1
1
1
0
0
1
0
2
0
1
1
1
0
0
0
0
3
0
1
0
0
0
0
1
0
4
1
1
0
1
1
0
0
0
5
0
1
1
1
0
0
0
0
6
0
1
0
0
0
0
0
0
7
1
1
0
1
1
0
0
0
8
0
1
1
1
0
0
0
0
9
0
1
0
0
0
0
1
0
10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34
1 0 1 1 0 1 1 0 1 1 0 1 0 0 1 0 1 1 1 1 0 0 0 0 0
1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 0 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 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 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 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0
0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 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 1 0 0 0
s13
m3
rb
m3
wa
m3
wb
bgc=0
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.