Automatic generation of instruction sequences targeting hard-to-detect structural faults in a processor

Sankar Gurumurthy, Shobha Vasudevan, Jacob A. Abraham

Research output: Chapter in Book/Report/Conference proceedingConference contribution

Abstract

Testing a processor in native mode by executing instructions from cache has been shown to be very effective in discovering defective chips. In previous work, we showed an efficient technique for generating instruction sequences targeting specific faults. We generated tests using traditional techniques at the module level and then mapped them to instruction sequences using novel methods. However, in that technique, the propagation of module test responses to primary outputs was not automated. In this paper, we present the algorithm and experimental results for a technique which automates the functional propagation of module level test responses. This technique models the propagation requirement as a Boolean difference problem and uses a bounded model checking engine to perform the instruction mapping. We use a register transfer level (RT-Level) abstraction which makes it possible to express Boolean difference as a succinct linear time logic (LTL) formula that can be passed to a bounded model checking engine. This technique fully automates the process of mapping module level test sequences to instruction sequences.

Original languageEnglish (US)
Title of host publication2006 IEEE International Test Conference, ITC
DOIs
StatePublished - Dec 1 2007
Externally publishedYes
Event2006 IEEE International Test Conference, ITC - Santa Clara, CA, United States
Duration: Oct 22 2006Oct 27 2006

Publication series

NameProceedings - International Test Conference
ISSN (Print)1089-3539

Other

Other2006 IEEE International Test Conference, ITC
CountryUnited States
CitySanta Clara, CA
Period10/22/0610/27/06

Fingerprint

Model checking
Engines
Testing

ASJC Scopus subject areas

  • Engineering(all)

Cite this

Gurumurthy, S., Vasudevan, S., & Abraham, J. A. (2007). Automatic generation of instruction sequences targeting hard-to-detect structural faults in a processor. In 2006 IEEE International Test Conference, ITC [4079354] (Proceedings - International Test Conference). https://doi.org/10.1109/TEST.2006.297676

Automatic generation of instruction sequences targeting hard-to-detect structural faults in a processor. / Gurumurthy, Sankar; Vasudevan, Shobha; Abraham, Jacob A.

2006 IEEE International Test Conference, ITC. 2007. 4079354 (Proceedings - International Test Conference).

Research output: Chapter in Book/Report/Conference proceedingConference contribution

Gurumurthy, S, Vasudevan, S & Abraham, JA 2007, Automatic generation of instruction sequences targeting hard-to-detect structural faults in a processor. in 2006 IEEE International Test Conference, ITC., 4079354, Proceedings - International Test Conference, 2006 IEEE International Test Conference, ITC, Santa Clara, CA, United States, 10/22/06. https://doi.org/10.1109/TEST.2006.297676
Gurumurthy S, Vasudevan S, Abraham JA. Automatic generation of instruction sequences targeting hard-to-detect structural faults in a processor. In 2006 IEEE International Test Conference, ITC. 2007. 4079354. (Proceedings - International Test Conference). https://doi.org/10.1109/TEST.2006.297676
Gurumurthy, Sankar ; Vasudevan, Shobha ; Abraham, Jacob A. / Automatic generation of instruction sequences targeting hard-to-detect structural faults in a processor. 2006 IEEE International Test Conference, ITC. 2007. (Proceedings - International Test Conference).
@inproceedings{d0de1f282c744880b1d069cc396654b3,
title = "Automatic generation of instruction sequences targeting hard-to-detect structural faults in a processor",
abstract = "Testing a processor in native mode by executing instructions from cache has been shown to be very effective in discovering defective chips. In previous work, we showed an efficient technique for generating instruction sequences targeting specific faults. We generated tests using traditional techniques at the module level and then mapped them to instruction sequences using novel methods. However, in that technique, the propagation of module test responses to primary outputs was not automated. In this paper, we present the algorithm and experimental results for a technique which automates the functional propagation of module level test responses. This technique models the propagation requirement as a Boolean difference problem and uses a bounded model checking engine to perform the instruction mapping. We use a register transfer level (RT-Level) abstraction which makes it possible to express Boolean difference as a succinct linear time logic (LTL) formula that can be passed to a bounded model checking engine. This technique fully automates the process of mapping module level test sequences to instruction sequences.",
author = "Sankar Gurumurthy and Shobha Vasudevan and Abraham, {Jacob A.}",
year = "2007",
month = "12",
day = "1",
doi = "10.1109/TEST.2006.297676",
language = "English (US)",
isbn = "1424402921",
series = "Proceedings - International Test Conference",
booktitle = "2006 IEEE International Test Conference, ITC",

}

TY - GEN

T1 - Automatic generation of instruction sequences targeting hard-to-detect structural faults in a processor

AU - Gurumurthy, Sankar

AU - Vasudevan, Shobha

AU - Abraham, Jacob A.

PY - 2007/12/1

Y1 - 2007/12/1

N2 - Testing a processor in native mode by executing instructions from cache has been shown to be very effective in discovering defective chips. In previous work, we showed an efficient technique for generating instruction sequences targeting specific faults. We generated tests using traditional techniques at the module level and then mapped them to instruction sequences using novel methods. However, in that technique, the propagation of module test responses to primary outputs was not automated. In this paper, we present the algorithm and experimental results for a technique which automates the functional propagation of module level test responses. This technique models the propagation requirement as a Boolean difference problem and uses a bounded model checking engine to perform the instruction mapping. We use a register transfer level (RT-Level) abstraction which makes it possible to express Boolean difference as a succinct linear time logic (LTL) formula that can be passed to a bounded model checking engine. This technique fully automates the process of mapping module level test sequences to instruction sequences.

AB - Testing a processor in native mode by executing instructions from cache has been shown to be very effective in discovering defective chips. In previous work, we showed an efficient technique for generating instruction sequences targeting specific faults. We generated tests using traditional techniques at the module level and then mapped them to instruction sequences using novel methods. However, in that technique, the propagation of module test responses to primary outputs was not automated. In this paper, we present the algorithm and experimental results for a technique which automates the functional propagation of module level test responses. This technique models the propagation requirement as a Boolean difference problem and uses a bounded model checking engine to perform the instruction mapping. We use a register transfer level (RT-Level) abstraction which makes it possible to express Boolean difference as a succinct linear time logic (LTL) formula that can be passed to a bounded model checking engine. This technique fully automates the process of mapping module level test sequences to instruction sequences.

UR - http://www.scopus.com/inward/record.url?scp=39749169032&partnerID=8YFLogxK

UR - http://www.scopus.com/inward/citedby.url?scp=39749169032&partnerID=8YFLogxK

U2 - 10.1109/TEST.2006.297676

DO - 10.1109/TEST.2006.297676

M3 - Conference contribution

SN - 1424402921

SN - 9781424402922

T3 - Proceedings - International Test Conference

BT - 2006 IEEE International Test Conference, ITC

ER -