Test de l’unité d’exécution d’une instruction par application d’instructions de test

Test de l’unité d’exécution d’une instruction par application d’instructions de test

Projet du cours ELE6306 : Tests des systèmes électroniques.

Nicolas Beucher.

Vincent Binet.


Plan

• Introduction - Problématique

• Revue de littérature sur le test basé sur le logiciel

• Présentation de l’architecture du Xtensa

• Génération et utilisation des vecteurs de test

• Résultats

• Conclusion


Plan





• Résultats

• Conclusion

Introduction - Problématique

• Microprocesseurs : complexes, pipelinés, rapides.

• ASIP : processeurs à jeu d’instruction spécialisé.

• Test d’un microprocesseur à vitesse réelle coûteux.

Machines de test ne peuvent pas opérer à cette vitesse.

• BIST coûteux et dégrade les performances.

Logique supplémentaire et horloge moins rapide

• Nécessité de tester autrement.

SOLUTION : Test basé sur des instructions

software-based self testing


Introduction - Problématique

• Création de programme de test :

Fonctionnent à vitesse réelle.

Ne nécessitent aucune logique supplémentaire.

Permettent de réaliser des tests de bonne qualité.

• On utilise le Processeur Xtensa de Tensilica pour appliquer cette méthode de test.



Plan





• Résultats

• Conclusion

•Principe :

Description au niveau porte du processeur

Vecteurs de test permettant d’identifier les fautes de collage

Programme permettant de générer les instructions et les données de test engendrant les vecteurs de test

•Test du processeur :

ATPG

Revue de littérature sur le test basé sur le logiciel



Différentes méthodes :

•Test de haut niveau avec des instructions aléatoires (faible taux de couverture) [4]

•Test basé sur une description bas niveau (portes) du processeur (taux de couverture plus élevé mais coûteux en temps [2]

•Test haut niveau (RTL) : taux de couverture élevé, plus rapide [5]

•Test haut niveau (RTL) couplé avec une analyse détaillée pour les modules présentant une structure régulière [1]

[1] N. Kranitis, A. Paschalis, D. Gizopoulos, and G. Xenoulis, “Software-based self-testing of embedded processors,” Computers, IEEE Transactions on, vol. 54, no. 4, pp. 461–475, 2005.[2] L. Chen and S. Dey, “Software-based self-testing methodology for processor cores,” Computer-Aided Design of Integrated Circuits and Systems,IEEE Transactions on, vol. 20, no. 3, pp. 369–380, 2001.[4] K. Batcher and C. Papachristou, “Instruction randomization self test for processor cores,” in VLSI Test Symposium, 1999. Proceedings. 17th IEEE, 1999, pp. 34–40.[5] N. Kranitis, D. Gizopoulos, A. Paschalis, and Y. Zorian, “Instructionbased self-testing of processor cores,” in VLSI Test Symposium, 2002. (VTS 2002). Proceedings 20th IEEE, 2002, pp. 223–228.


Comparaison des différentes techniques :

Aire Additionnelle

(%)

Taux de couverture

(%)

A la vitesse de fonctionnement

?

Équipement de test

externe ?

Taille du programme/ Taille

des réponses

(en bytes)

Temps d’exécution

(cycles)

Chaîne de scan

11.95 89.39 NON OUI N/A N/A

BIST 169.09 88.69 OUI NON N/A N/A

Technique [2]

0 91.42 OUI NON 1129/514 137 649

Technique [5]

0 91.34 OUI NON 923 /124 16 667


Technique [2] : description du processeur niveau porte

Technique [5] : description haut niveau (RTL)



Amélioration de la technique [1] par rapport à l’ATPG classique

pour une structure régulière du type Multiplieur :

Taille du code

(mots)

Nombre de cycles

Taux de couverture

ATPG 373 3895 99.5 %

Technique [1] 28 3122 99 %

Opérandes de la forme [preuve]

X=XN-1 …..X1X0 = (C7C6C5C4) …… ……. (C7C6C5C4)

Y= YN-1 …..Y1Y0 = (C3C2C1C0) …… ……. (C3C2C1C0)

Technique [1] : RTL + analyse des structures régulières

[preuve] Gizopoulos, D.; Paschalis, A.; Zorian, Y., "An effective built-in self-test scheme for parallel multipliers," Computers, IEEE Transactions on , vol.48, no.9pp.936-950, Sep 1999



Plan





• Résultats

• Conclusion

Présentation de l’architecture Xtensa

• Processeur configurable (ASIP).

• Possibilité de création d’un jeu d’instruction spécialisé.

• Processeur pipeliné à 5 étages :

étage de chargement d ’instruction I.

étage de décodage et chargement des registres R.

étage d’exécution E.

étage de relation mémoire M (deuxième niveau d’exécution si nécessaire).

étage de writeback W (écriture du résultat dans les registres).


PCInst

Memory

Decode

RegfileExecution

UnitRegfile update

I R E M W




• Conception de processeurs adaptés aux besoins

• Fournis avec des outils de simulation et de création

• Le processeur possède deux méthodes pour le test :

Le JTAG

Les programmes de test



Plan





• Résultats

• Conclusion

Génération et utilisation des vecteurs de test

• 2 instructions ont été utilisées : INDEXC et MULTI.

• MULTI réalise une multiplication entière 16 bits signée.

• INDEXC réalise un calcul d’adresse complexe dans un tableau.

• Complexité et utilisation des instructions différentes.



• Les unités d’éxécution, décrites au niveau porte, des 2 instructions sont testés.

• Avec un ATPG, on génère les vecteurs de test de chacune des unités.

• Le générateur retourne le nombre de vecteurs, les vecteurs, les résultats attendue pour chacun d’entre eux et le taux de couverture.

PCInst

Memory

Decode

RegfileExecution

UnitRegfile update

I R E M W

Génération des vecteurs de test.



• Les vecteurs sont ensuite traduits en valeurs à appliquer à l’instruction.

• Avec ces valeurs que l’on stocke dans un tableau, on appelle l’instruction au travers du programme de test.

• Le programme de test effectue alors la séquence suivante sur le processeur qui a pour effet de tester l’unité d’éxécution considérée.


PCInst

Memory

Decode

RegfileExecution

UnitRegfile update

I R E M W


Conversion en instructions des vecteurs : opérandes de l’instruction.


PCInst

Memory

Decode

RegfileExecution

UnitRegfile update

I R E M W


Conversion en instructions des vecteurs : Chargement des opérandes dans les registres.


PCInst

Memory

Decode

RegfileExecution

UnitRegfile update

I R E M W


Conversion en instructions des vecteurs : Application de l’instruction de test.


PCInst

Memory

Decode

RegfileExecution

UnitRegfile update

I R E M W


Conversion en instructions des vecteurs : Récupération du résultat.



• Les résultats obtenus sont testés avec les résultats attendus.

• Le programme s’arrête si le test détecte une erreur.

• Les acétates suivantes présentent les fonctions testant les instructions MULTI et INDEXC, ainsi que le programme de test complet.



• Test de l’instruction MULTI :

int test_MULTI(){int i,r ;

for(i=0 ;i<NVEC;i++){r = MULTI(op1[i],op2[i]);if(r !=result[i]) return i+1 ;

}

return 0 ;}

• C’est une instruction simple ce qui est reflété dans sa fonction de test.



• Test de l’instruction INDEXC :

int test_INDEXC(){int i,r ;

for(i=0 ;i<NVEC;i++){WUR_CUR_W(INDEXC_w[i]) ;WUR_CUR_X(INDEXC_cx[i]) ;WUR_CUR_Y(INDEXC_cy[i]) ;WUR_MIN_X(INDEXC_mx[i]) ;WUR_MIN_Y(INDEXC_my[i]) ;r = INDEXC(INDEXC_op1[i],INDEXC_op2[i]);if(r !=INDEXC_result[i]) return i+1 ;

}

return 0 ;}

• C’est une instruction plus complexe qui utilise des registres d’états du processeur en entrée. Ces registres font partie du vecteur de test.



• Test de registre :

int test_REG_CUR_X () {WUR_CUR_X(0x00000000);if(RUR_CUR_X() != 0x00000000) return 1;

WUR_CUR_X(0x00000000);if(RUR_CUR_X() != 0x00000000) return 1;

WUR_CUR_X(0xFFFFFFFF);if(RUR_CUR_X() != 0xFFFFFFFF) return 1;

WUR_CUR_X(0xFFFFFFFF);if(RUR_CUR_X() != 0xFFFFFFFF) return 1;WUR_CUR_X(0x00000000);if(RUR_CUR_X() != 0x00000000) return 1;return 0;

}

• On teste toutes les transitions possibles pour le registre.



• Programme de test complet :

…if(test_REG_CUR_X()) return 1;...if(test_INDEXC()) return 1 ;if(test_MULTI()) return 1 ;...

• On appelle successivement les fonctions de test des différentes instructions. Chaque retour de fonction doit indiqué un succès sinon le programme s’arrête.



Plan





• Résultats

• Conclusion

Résultats

Instruction Nombre de vecteurs

Taux de couverture (%)

Temps d’éxécution (cycles)

Temps réel (µs)

MULTI 32 98 1255 5,02

INDEXC 41 93,4 2940 12,948

REG_CUR_X 5 100 91 0,3

• Ces résultats sont cohérents avec la complexité de chaque instruction.


Résultats

• En considérant INDEXC comme un pire cas et MULTI comme un cas simple on peut extrapoler ces résultats pour le jeu d’instruction complet.

• 80 instructions de base + 20 instructions spécialisées.

• 10 µs de test par instruction (estimation haute).


1ms pour tester toutes les unités d’exécution du processeur.


Plan





• Résultats

• Conclusion

• Nécessité d’un test basé sur le logiciel pour tester les processeurs d’aujourd’hui

• Plusieurs techniques différentes ( niveau portes, niveau RTL)

• Avantages du test basé sur le logiciel : Utilise les ressources déjà présentes du processeurs Taux de couverture élevé Sans équipement de test coûteux A vitesse Réelle

• Application au processeur Xtensa de Tensilica

Conclusion


Taux de couverture de 95 %, temps de test de l’ordre de la ms

Questions

?


Documents

Test de l’unité d’exécution d’une instruction par application d’instructions de test