DE69329720T2

DE69329720T2 - Transparentes testen von integrierten schaltkreisen

Info

Publication number: DE69329720T2
Application number: DE69329720T
Authority: DE
Inventors: Michael Nicolaidis
Original assignee: Iroc Technologies SA
Current assignee: Iroc Technologies SA
Priority date: 1992-03-05
Filing date: 1993-03-05
Publication date: 2002-08-22
Anticipated expiration: 2013-03-06
Also published as: EP0585435A1; ATE198000T1; EP0585435B1; DE69329720D1; US5469445A; WO1993018457A1; GR920100088A

Description

Die Erfindung betrifft ein Verfahren, das es erlaubt, integrierte Schaltungen ohne Verlust des Kontextes der ausgeführten Anwendung zu testen.
Seit einiger Zeit setzen sich Prüfpfad- und BIST-Techniken (siehe H. FUJIWARA "Logic Testing and Design for Testability" The MIT Press, 1985, Cambridge, Massachusetts, London) beim Testen von integrierten Schaltungen (ICs) durch, und viele IC-Hersteller beziehen solche Testeinrichtungen in ihre Produkte ein. Prüfpfad- und BIST-Einrichtungen, die für den Produktionstest von ICs implementiert wurden, erlauben auch, das Testen von ICs auf der Leiterplatte und in den Systemebenen bedeutend zu vereinfachen. Verschiedene Anwendungen erfordern, die ICs des Systems periodisch zu testen (Offline-Test). Existierende Prüfpfad- und BIST-Verfahren sind für solche Zwecke nicht geeignet, da sie den internen Zustand der integrierten Schaltung verändern. Diese Arbeit ist darauf gerichtet, mit diesem Problem klarzukommen. Die vorgeschlagenen Verfahren betrachten zwei Arten von Blöcken: kombinatorische und sequentielle Blöcke auf der einen Seite (sie werden Logikblöcke genannt) und verschiedene RAMs und Registersätze auf der anderen Seite. Für die erste Art von Blöcken benutzen wir ein Sicherungs-, Test- und Wiederherstellungs-Verfahren, das auf dem Prüfpfad-Entwurf basiert. Für die zweite Art von Blöcken würde ein Sicherungs-, Test- und Wiederherstellungs-Verfahren eine RAM-Verdopplung erfordern, was in einem hohen Flächenverbrauch resultieren würde. Um mit diesem Problem klarzukommen ziehen wir Nutzen aus der Regularität der RAMs und ihrer Test-Algorithmen, und wir schlagen ein transparentes Testverfahren vor, das heißt, ein Verfahren, das es erlaubt die RAMs zu testen, ohne ihren anfänglichen Inhalt zu zerstören.
Die Erfindung wird nachstehend beschrieben mit Bezug auf die damit verbundenen Zeichnungen, die folgende Bedeutung haben:
Fig. 0 ist ein Blockdiagramm, welches den kreisförmigen Prüfpfad für das Sichern und Wiederherstellen des Inhalts der Kontext-sensiblen Register illustriert.
Fig. 1a ist ein Blockdiagramm, welches die Struktur von Wörtern in RAMs ohne Multiplexen der Spalten illustriert.
Fig. 1b ist ein Blockdiagramm, welches die Struktur von Wörtern in RAMs mit einem 1-aus-2- Multiplexen der Spalten illustriert.
Fig. 1c ist ein Blockdiagramm, welches die Struktur von Wörtern in RAMs mit einem 1-aus-4- Multiplexen der Spalten illustriert.
Fig. 2 ist ein Blockdiagramm, welches den Sequenz-Steuerblock für den transparenten BIST illustriert.
Fig. 3 ist ein Blockdiagramm, welches ein Aufwärts-/Abwärts-LFSR mit externem XOR illustriert.
Fig. 4 ist ein Blockdiagramm, welches ein Aufwärts-/Abwärts-LFSR mit einer NOR-Funktion in der Rückkopplungsschleife illustriert.
Fig. 5 ist ein Blockdiagramm, welches den Zeitpunkt-Generator für den transparenten BIST illustriert.
Fig. 6 ist ein Blockdiagramm, welches den Testdaten-Generator für den transparenten BIST illustriert.
Fig. 7 ist ein Blockdiagramm, welches ein Aufwärts-/Abwärts-Signaturregister auf der Basis eines Aufwärts-/Abwärts-LFSR's mit externem XOR illustriert.
Fig. 8 ist ein Blockdiagramm, welches die Testdaten-Erzeugung für den Prüfpfad-basierten transparenten Test illustriert.
Fig. 9 ist ein Blockdiagramm, welches einen eingebetteten RAM illustriert.
Fig. 10 ist ein Blockdiagramm, welches eine RAM-Adressierungsanordnung unter Verwendung eines Prüfpfads illustriert.
Fig. 11 ist ein Blockdiagramm, welches einen globalen BIST unter Verwendung eines Prüfpfads illustriert.

TRANSPARENTES TESTEN VON LOGIKBLÖCKEN:

Der Ausführungskontext einer Anwendung eines ICs hängt vom Inhalt des Zustandsregisters eines sequentiellen Blocks und vom Inhalt der Ein-/Ausgabe-Register eines sequentiellen oder kombinatorischen Blocks ab. Diese Register werden Kontext-sensible Register genannt. Die Offline-Testsitzung darf nicht den Verlust des Inhalts dieser Register verursachen. Prüfpfad-Verfahren sind sehr populär für das Testen der kombinatorischen und sequentiellen Blöcke von ICs. Während der Testsitzung transformiert dieses Verfahren die Zustands und/oder Ein-/Ausgabe-Register der Logikblöcke in ein Schieberegister. Die resultierenden Schieberegister sind miteinander verbunden, um einen Prüfpfad zu formen, der es erlaubt, die Testvektoren an die Eingänge jedes Blocks zu bringen und die Ausgabe-Antworten der Blöcke hinaus zu bringen.
Für die Zwecke des Offline-Tests können die Prüfpfad-Einrichtungen benutzt werden, um den Verlust des Inhalts der Kontext-sensiblen Register zu vermeiden. Um dies zu tun sind alle Kontextsensiblen Register in einen oder mehrere Prüfpfade einbezogen. Die Sicherungs-, Test- und Wiederherstellungsphasen sind wie folgt:
Vor dem Start der Testsitzung wird der Inhalt der Kontext-sensiblen Register bis zu den Dateneingängen eines RAMs verschoben und in diesen RAM geschrieben. Der Speicher, der zu diesem Zweck benutzt wird, kann ein externer Speicher sein oder ein auf der integrierten Schaltung existierender Speicher oder sogar ein zum Zweck dieser Operation in den IC implementierter Hilfsspeicher. Entsprechend der Anzahl und der Größe der Kontext-sensiblen Register und der Größe der RAM-Wörter wird der Inhalt dieser Register in verschiedenen RAM- Wörtern gesichert. Ist die Größe eines Registers größer als die Größe des RAM-Wortes, so wird sein Inhalt in verschiedenen RAM-Wörtern gesichert. Sind zwei Register in aufeinander folgenden Positionen im Prüfpfad, und ist ihre Gesamtanzahl von Bits geringer als die Anzahl der Bits der RAM-Wörter, so können sie im selben RAM-Wort gespeichert werden. Allgemeiner, wenn verschiedene Kontext-sensible Register in aufeinander folgenden Positionen im Prüfpfad sind und sie eine Gesamtanzahl von n Bits haben, und wenn jedes RAM-Wort k Bits hat, dann kann der Inhalt dieser Register in 5n/kº RAM-Wörtern gespeichert werden.
Wenn der gesamte Inhalt der Kontext-sensiblen Register gespeichert wurde, führen wir die Offline- Testsitzung durch.
Nach dem Ende dieser Sitzung wird der Inhalt der Kontext-sensiblen Register wieder hergestellt. Um dies zu tun werden die RAM-Wörter, die einige dieser Daten enthalten gelesen und in den Prüfpfad wie folgt geladen:
- zuerst wird das Wort, welches als erstes in den RAM geladen wurde (während der Sicherungs-Phase) gelesen und in den Prüfpfad geladen,
- dann führen wir einige Schiebe-Operationen aus und wir laden dasjenige Wort in den Prüfpfad, welches als zweites in den RAM geladen wurde usw. Die Anzahl der Verschiebungen hängt von der Größe der RAM-Wörter ab, von der Größe der Kontext-sensiblen Register und von ihrer relativen Position in der Prüfpfadkette. Diese Operationen erlauben, die Daten adäquat in den Prüfpfad zu laden.
Dann führen wir einige Schiebe-Operationen aus, um die Daten in die jeweiligen Register zu platzieren. Um die letzte Operation zu ermöglichen, muß der Prüfpfad kreisförmig sein (d. h. der Ausgang der letzten Stufe ist mit dem Eingang der ersten Stufe verbunden), wie in Fig. 0 illustriert ist.

TRANSPARENTES TESTEN VON RAMS:

Im folgenden betrachten wir den Fall von verschiedenen RAMs und Registersätzen (welche RAMs genannt werden) und präsentieren eine transparentes Testverfahren, das heißt, ein Verfahren, das es erlaubt, RAMS zu testen, ohne ihren anfänglichen Inhalt zu zerstören. Dieses Verfahren kann mit Hilfe von BIST- oder Prüfpfad-Verfahren implementiert werden.

RAM-Fehlermodelle:

Bevor wir das transparente RAM-Testverfahren beschreiben, stellen wir die existierenden RAM- Fehlermodelle vor. Haftfehler, Übergangsfehler, Kopplungsfehler und Muster-abhängige Fehler sind weithin anerkannte Klassen von vorherrschenden Fehlern, die in Lese-Schreib-Speichern vorkommen (z. B. "THATTE S. M, ABRAHAM J. A. "Testing of semiconductor random access memories" - IEEE Transactions on Computers Vol. C-26, Juni 1978", "SUK D. S., REDDY S. M. "Test procedures for a class of pattern sensitive faults in semiconductor random access memories" IEEE Transactions on Computers, Vol. C-34, Nr. 2, S. 110-116, Februar 1985", "Marinescu M. "Simple and efficient algorithms for functional RAM testing", IEEE International Test Conference, November 1982", "HAYES J. P. "Testing memories for single-cell pattern sensitive fault", IEEE Transactions on Computers, Vol. C-29, Nr. 3, März 1980" und "SUK D. S., REDDY S. M., "A march test for functional faults in semiconductor random access memories", IEEE Transactions on Computers, Vol. C-30, Nr. 12, Dezember 1981 "). Sie können wie in "VAN DE GOOR A. J., VERRUIJT C. A., "An overview of deterministic functional RAM chip testing", ACM Computing Surveys, Vol. 22, Nr. 1, März 1990" klassifiziert werden:
1) Haftfehler: Ein permanenter Haftfehler 0 oder Haftfehler 1 kann in jeder Speicherzelle auftreten.
2) Übergangsfehler: Eine Speicherzelle im Zustand s (s {0, 1}) versagt, einen s nach Übergang zu vollziehen, wenn in die Zelle geschrieben werden soll.
3) Kopplungsfehler: Eine Schreiboperation, die einen 0-> 1 oder einen 1-> 0 Zustandsübergang in einer Zelle cj bewirkt (sagen wir, Übergang t), ändert den Zustand einer anderen Speicherzelle ci(i j) von s nach , unabhängig vom Inhalt der anderen Zellen. Dieser Fehler wird dargestellt als T(is, jt). (Marinescu M. "Simple and efficient algorithms for functional RAM testing", IEEE International Test Conference, November 1982) klassifiziert die Kopplungsfehler wie folgt:
- idempotente (oder nicht-invertierende) Kopplungsfehler, das heißt: ein positiver (oder negativer) Übergang in einer Zelle cj zwingt eine andere Zelle ci auf einen bestimmten Wert, 0 or 1.
- invertierende Kopplungsfehler, das heißt: ein positiver (oder negativer) Übergang in einer Zelle cj invertiert den Inhalt einer Zelle ci.
Aktive und passive Muster-abhängige Fehler wurden ebenfalls definiert (siehe (SUK D. S., REDDY S. M. "Test procedures for a class of pattern sensitive faults in semiconductor random access memories", IEEE Transactions on Computers, Vol. C-34, Nr. 2, S. 110-116, Februar 1985):
4) Passive Muster-abhängige Fehler (PNPSF): wenn die Zustände einiger Zellen c1, c2, ..., ck einige spezielle Werte s&sub1;, s&sub2;,..., sk haben, und wenn s der Zustand der Zelle ci ist, dann können wir nicht s in die Zelle c1 schreiben. Dieser Fehler wird dargestellt als PN(is, 1s1,2s2,...,ksk).
5) Aktive Muster-abhängige Fehler (ANPSF): wenn die Zustände einiger Zellen c1, c2,..., ck (oft angenommen, in der Nachbarschaft der Basiszelle ci zu sein) einige spezielle Werte s&sub1;, s&sub2;, ..., sk haben, dann ändert der Übergang der Zelle cj von t nach t den Zustand der Zelle ci von s nach . Dieser Fehler wird dargestellt als AN(is, jt, 1s1, 2s2, ksk). Beachte, daß Kopplungsfehler ein spezieller Fall von ANPSF ist, für den die gelöschte Nachbarschaft leer ist. Einige Autoren haben auch Variationen dieser Fehlermodelle studiert, zum Beispiel statische und dynamische Muster-abhängige Fehler (siehe SALUJA K. K., KINOSHITA K. - "Test pattern generation for API faults in RAM. IEEE Transactions on Computers, C-34,3, März 1985).
6) Letztendlich können Dekoder- und LESE-/SCHREIB-Logikfehler als Speicherzellenfeld-Fehler modelliert werden (siehe NAIR. R THATTE S. M, ABRAHAM J. A. "Efficient algorithms for testing semiconductor Random-Access Memories", IEEE Transactions on Computers, Vol. C-27, S. 572-576, Juni 1978, und auch THATTE S. M, ABRAHAM J. A. "Testing of semiconductor random access memories", Proc. 7th International Symposium on Fault tolerant Computing) und müssen nicht explizit betrachtet werden.

Vorbetrachtungen zum transparenten BIST für RAMs:

Um den Verlust des Kontextes einer integrierten Schaltung bei der Ausführung einer Anwengung zu vermeiden wenn wir einen RAM-Block testen, werden wir eine transparentes BIST-Anordnung verwenden, das heißt, eine BIST-Anordnung, welche gestattet, den RAM zu testen, ohne seinen anfänglichen Inhalt zu zerstören.
Die Pionierarbeit auf diesem Gebiet wurde von B. Koeneman auf dem DFT-Workshop 1986 in Vail, Colorado, präsentiert. Dies ist die einzige bekannte Arbeit auf diesem Gebiet. Dieses Verfahren basiert auf der Linearität der Signaturregister. Der Test-Algorithmus ist aus verschiedenen Elementar-Testabschnitten zusammengestzt. Bei A ein geordneter Datenfolge und sei s(A) seine Signatur. Bei TP ein Testmuster. Jeder Testabschnitt ist wie folgt aufgebaut:
Start: Setzte Signatur zurück
Schleife1: Lese (INHALT), berechne Signatur s(INHALT) und schreibe (INHALT.XOR.TP) = NEUER INHALT.
Dann: Sichere s(INHALT) und setze Signatur zurück.
Schleife2: Lese (NEUER INHALT), berechne Signatur s(NEUER INHALT), schreibe (NEUER INHALT.XOR.TP).
Ende: Resultat: s(NEUER INHALT).XOR.s(INHALT).
Im obigen Prozeß werden die in den Schleifen 1 und 2 beschriebenen Operationen auf alle Speicherzellen angewendet. Am Ende des Elementarabschnitts sind die RAM-Inhalte wieder hergestellt, da die Inhalte am Ende NEUER INHALT.XOR.TP = INHALT.XOR.TP.XOR.TP = INHALT sind. Somit ist das Abschnitt transparent.
Wenn mehrere Abschnitte miteinander verkettet sind, dann kann die Wiederherstellungs-Operation (d. h. die Schreib-Operation in Schleife 2) weggelassen werden. Es wird nur eine Wiederherstellungsoperation pro Zelle am Ende des gesamten Test-Algortihmus verwendet (wenn überhaupt).
Aufgrund der Linearität der MISRs (Multiple Input Signature Registers) haben wir s(NEUER INHALT) = s(INHALT.XOR.TP) = s(INHALT).XOR.s(TP). Die Signatur am Ende ist dann Resultat = s(NEUER INHALT).XOR.s(INHALT) = s(TP), und somit voraussagbar.
Das obige Verfahren hat die folgenden Nachteile:
a) Ein erster Nachteil ist, daß das Verfahren nur funktioniert, wenn die Prüfung der Ausgabeantworten mit einem linearen Kompaktierer gemacht wird.
b) Der zweite Nachteil des Verfahrens ist, daß für einige Fehler die gelesenen Daten dieselbe Fehlerfolge E sowohl bei Schleife1 als auch bei Schleife2 enthalten können. Daher sind die resultierenden Signaturen s(INHALT.XOR.E) und s(NEUER INHALT.XOR.E), und die Signatur am Ende ist s(INHALT.XOR.E.XOR.INHALT.XOR.TP.XOR.E) = s(TP), welche mit der korrekten Signatur übereinstimmt. Daher ist der Fehler maskiert, obwohl die angewendeten Testmuster eine fehlerhafte Antwort produzieren. Dies rührt von der Tatsache, daß wir XOR auf zwei Signaturen anwenden, welche beide über die vom gleichen fehlerhaften RAM generierten Daten genommen werden. Das Auftreten desselben fehlerhaften Folge in Schleife1 und Schleife2 kann durch das folgende Beispiel illustriert werden. Betrachtet sei ein RAM mit 3 Zellen C1, C2 und C3 und sei der Anfangsinhalt dieser Zellen 1,0 bzw. 0. Wir wenden Koenemans Verfahren für einen Test an, welcher das Muster TP = 1,1,1 auf diese Zellen anwendet. Die Lese- und Schreiboperationen während Schleife1 und Schleife2 sind:
Die Folge, der bei Schleife1 gelesen wird, ist 1,0,0 und wir haben s(INHALT) = s(1,0,0) und die Folge, der bei Schleife2 gelesen wird, ist 0,1,1 und wir haben s(NEUER INHALT) = s(0,1,1). Somit ist s(INHALT).XOR.s(NEUER INHALT) = s(1,0,0).XOR.s(0,1,1) = s(1.XOR.0,0.XOR.1,0.XOR.1) = s(1,1,1) = s(TP).
Wir ziehen nun in Betracht, daß der Speicher einen Kopplungsfehler enthält, so daß der Übergang 1 → 0 der Zelle C1 den Zustand der Zelle C2 von 0 nach 1 modifiziert. Aufgrund dieses Fehlers wird die Schreib-Operation auf Zelle C1 während Schleife1 den Zustand der Zelle C2 zu 1 ändern. Daher werden wir in Schleife1 von Zelle C2 den Wert 1 lesen und wir werden 1.XOR.1 = 0 in diese Zelle schreiben. In Schleife2 werden wir 0 aus Zelle C2 lesen und wir werden O.XOR.1 = 1 schreiben. Alle anderen Operationen sind wie im fehlerfreien RAM. Die zwei Schleifen sind:
Bei Schleife1 wird die Signatur s(1,1,0) sein und die Signatur bei Schleife2 wird s(0,0,1) sein. Dann haben wir s(1,1,0).XOR.s(0,0,1) = s(1.XOR.0,1.XOR.0,0.XOR.1) = s(1,1,1) = s(TP), und der Fehler wird nicht erkannt. Eine ähnliche Situation kann bei der Betrachtung einiger Muster-abhängiger Fehler auftreten.
Um mit diesem Problem klarzukommen sagt unser Verfahren die Signatur voraus, durch Benutzung einer Folge, die nur Lese-Operationen ausführt, und danach wenden wir unser transparentes Testmuster an. Wie wir später zeigen, bekämpft dieses Verfahren den Nachteil von Punkt b (siehe Lemma 3) und auch den von Punkt a.
c) Der dritte Nachteil ist, daß die vorgeschlagenen transparenten Testmuster durch Elementarschleifen zusammengesetzt werden, welche eine Lese- und eine Schreiboperation auf jede Zelle anwenden. Jedoch, die meisten der existierenden RAM-Testmuster enthalten Schleifen mit einer komplexeren Struktur (siehe zum Beispiel Tabelle I).
Unser Verfahren basiert auch auf Koenemans Idee, den Inhalt des RAMs zu nutzen, um ihn zu testen. Aber anstelle einen vorbestimmten Schleifentyp zu nutzen geht es von irgendeinem existierenden Testalgorithmus aus und transformiert ihn in einen transparenten. Somit werden wir mit diesen Nachteil fertig.
d) Der letzte Nachteil von Koenemans Verfahren betrifft die Fehlerüberdeckung. Da der transparente BIST die Nutzung neuer Testalgorithmen erfordert, ist die Fehlerüberdeckung nicht garantiert. Koenemans Arbeit gibt kein Verfahren an, das es erlaubt zu überprüfen, ob die Fehlerüberdeckung verringert ist. In der vorliegenden Arbeit geben wir ein Kriterium an, welches erlaubt, sehr einfach zu prüfen, ob unser transparenter BIST die Fehlerüberdeckung des ursprünglichen Algorithmus bewahrt (siehe Theorem 1), und wir zeigen, daß es für die meisten der bekannten RAM-Fehlermodelle keine Verringerung der Fehlerüberdeckung gibt.

Allgemeine Richtlinien zum Transformieren eines RAM-Testalgorithmus in einen transparenten:

Die folgenden Transformationen werden für Bit-orientierte RAMs veranschaulicht, aber sie gelten auch für Wort-orientierte RAMs (in diesem Fall wenden wir die Transformationen auf jedes Bit des Wortes an). Diese Transformationen gelten auch für Single-Port- und Multi-Port-RAMs. Im Falle von Multi-Port-RAMs werden die Transformationen auf die Testdaten angewandt, die auf jeden RAM-Port angewendet werden.
Ein RAM-Testalgorithmus ist zusammengesetzt aus verschiedenen Sequenzen (Schleifen). Für jede adressierte Zelle innerhalb einer Sequenz führt man mehrere Lese- und Schreib-Operationen aus. Im allgemeinen startet ein Testalgorithmus mit dem Initialisieren des RAMs. Dies kann durch eine Initialisierungs-Sequenz erfolgen, die aus mehreren Schreib-Operationen zusammengesetzt ist. Alternativ kann dies durch mehrere Schreib-Operationen gemacht werden, die in die erste Sequenz des Algorithmus eingebaut sind. Das heißt, in dieser Sequenz startet jede Folge von Operationen, die auf eine Zelle wirken, mit einer Initialisierungs-Operation (d. h. einer Schreib- Operation). In den Sequenzen der meisten der bekannten deterministischen RAM-Testmuster ist die erste Operation auf jede Zelle eine Lese-Operation (ausgenommen während der Sequenz, die die Initialisierungs-Operationen enthält), aber nehmen wir an, daß in einigen Algorithmen die erste Operation, die in einer adressierten Zelle ausgeführt wird, ein Schreiben ist. Bei ALin der Algorithmus, von dem wir ausgehen. Dann benutzen wir den ersten Transformationsschritt.
Schritt 0: Ist die erste Operation einer Folge aufeinander folgender Operationen, die auf eine Speicherzelle i angewandt werden, eine schreibende, so füge eine Lese-Operation an den Anfang der Folge dazu.
Beispiel: Bei beispielsweise der Algorithmus ALin wie folgt:
Dann ergibt Schritt 0 den folgenden Algorithmus (a1, a2 und a3 sind die Werte, die sich bei den ersten Lese-Operationen der Speicherzellen ergeben):
Im allgemeinen enthalten die RAM-Testalgorithmen eine Initialisierungs-Sequenz (oder einige in die erste Sequenz des Algorithmus eingebundene Initialisierungs-Operationen). Für die Mehrheit dieser Algorithmen ist diese Sequenz (bzw. diese Operationen) nicht brauchbar für die Sensibilisierung der Fehler, aber sie wird benutz, um den Speicher in einen bekannten Zustand zu versetzen. Bei AL0 der aus Schritt 0 hervorgegangene Algorithmus.
Schritt 1: Wenn der Algorithmus ALin eine Initialisierungs-Sequenz enthält (bzw. einige Initialisierungs-Operationen) und wenn diese Sequenz (bzw. diese Operationen) unbrauchbar für das Sensibilisieren der Fehler ist, dann lösche diese Sequenz (bzw. diese Operationen) aus dem Algorithmus AL0.
Dieser Schritt ist nicht notwendig aber er reduziert die Testlänge ohne die Fehlerüberdeckung zu reduzieren.
Wenn die Initialisierungs-Sequenz unbrauchbar ist für die Sensibilisierung der Fehler, dann erhalten wir durch Anwendung von Schritt 1 den folgenden Algorithmus:
Bei AL1 der aus Schritt 1 hervorgegangene Algorithmus. Der Schritt 2 wird auf den Algorithmus AL1 wie folgt angewendet: Der Algorithmus AL1 führt eine Lese-Operation als erste Operation auf jede adressierte Zelle aus. Die gelesenen Daten werden in einem Register gespeichert und werden als Testdaten genutzt bis zur nächsten Lese-Operation.

Schritt 2:

a - Bei die Initialisierungs-Sequenz (bzw. die Initialisierungs-Operationen) brauchbar, dann haben wir den Algortihmus AL0 wie folgt zu transformieren: Bei ai der Wert, der aus der ersten Lese- Operation von einer Zelle i in Algorithmus AL0 resultiert. Betrachte die Schreib-Operationen auf Zelle i. Wenn der Wert einer Schreib-Operation 0 ist, so verwende a1 als Datum für die Schreib- Operation, andererseits verwende i als Datum für diese Operation. Alternativ können wir diesen Schritt ausführen, indem wir die Schreibwerte 0 durch i ersetzen und die Schreibwerte 1 durch ai.
b- Sei die Initialisierungs-Sequenz (bzw. die Initialisierungs-Operationen) unbrauchbar dann haben wir den Algortihmus AL1 wie folgt zu transformieren:
Sei S1' die erste Sequenz von Algorithmus AL1 und sei ai das Datum der ersten Lese-Operation von Zelle i in dieser Sequenz. Bei ri das Datum der ersten Lese-Operation von Zelle i in der Sequenz S1' von Algorithmus AL0. Bei wi das Datum einer Schreib-Operation von Zelle i in Algorithmus AL1. Wenn ri = wi dann verwende ai als Datum für diese Schreib-Operation, anderenfalls verwende als Datum für diese Operation.
In beiden Fällen a- und b- ist das Datum jeder Lese-Operation einer Zelle (ausgenommen der ersten Lese-Operation) gleich dem Datum der letzten Schreib-Operation der Zelle, die der gelesenen vorangeht.
Im Fall b- ist die Transformation so, daß wenn im ursprünglichen Algorithmus die erste Schreib- Operation einer Zelle i eine Zustandsänderung von i beinhaltet, dann passiert dies auch in Sequenz S1'. Dies wird nicht für die Sequenz Init' von Fall a- verlangt, weil die erste Schreib- Operationen der Sequenz Init des ursprünglichen Algorithmus den RAM initialisieren und daher Zustandsänderungen auf zufällige Weise beinhalten.
Der Schritt 2 bestimmt die Werte aller Lese- und Schreib-Operationen des Algorithmus als Funktionen des Anfangsinhaltes des RAM's.
Beispiel: Durch das Anwenden der Transformationen von Punkt a- auf den Beispiel-Algorithmus AL0 erhalten wir den folgenden Algorithmus:
Durch das Anwenden der Transformationen von Punkt b- auf den Beispiel-Algorithmus AL1 erhalten wir den folgenden Algorithmus:
Bei AL2 die Repräsentation des Algorithmus, der aus dem Schritt 2 resultiert. In diesem Algorithmus ist das erwartete Datum jeder Lese-Operation entweder gleich dem Anfangsdatum der Zelle oder seinem Inversen. Ebenso ist das erwartete Datum, das bei jeder Schreib-Operation zu verwenden ist, entweder gleich dem Anfangs-Datum der Zelle oder seinem Inversen.
Dann verwende den Schritt 3.
Schritt 3: Wenn die erwarteten Daten für die letzte Schreib-Operation bei einigen Zellen gleich dem Inversen ihrer Ausgangsdaten sind, dann füge am Ende des Algorithmus eine Sequenz hinzu, welche auf jeder dieser Zellen eine Lese-Operation ausführt, gefolgt von einer Schreib-Operation mit Daten, die invers zu den gelesenen Daten sind.
Offensichtlich sind nach diesem Schritt die RAM-Inhalte gleich ihren Anfangsinhalten. Beispiel: Durch Ausführen von Schritt 3 auf den Beispiel-Algorithmus AL2, der aus Schritt 2b- resultiert, erhalten wir folgenden Algorithmus:
Der Algorithmus AL3, der aus Schritt 3 resultiert, ist ein transparenter Testalgorithmus und wird der Grundalgorithmus für den transparenten Test genannt.
Der letzte Schritt wird verwendet, um einen Algorithmus zu bestimmen, der erlaubt, die Signatur, die durch den Grundalgorithmus für den transparenten Test erzeugt wird, vorherzusagen. Der resultierende Algorithmus wird Signatunrorhersage-Algorithmus genannt. Alternativ dazu können wir einen Algorithmus bestimmen (Signatur-Initialisierungs-Algorithmus genannt), welcher gestattet, einen Aufwärts-/Abwärts-Ausgabedaten-Kompaktierer mit einem Zustand derart zu initialisieren, daß nach der Anwendung des Grundalgorithmus für den transparenten Test die Endsignatur gleich dem Anfangszustand des Kompaktierers, und somit vorhersagbar ist. Die Aufwärts-/Abwärts-Ausgabedaten-Kompaktierer werden später beschrieben.
Schritt 4: Lösche alle Schreib-Operationen von Algorithmus AL3.
Beispiel: Durch Anwenden von Schritt 4 auf den Beispiel-Algorithmus AL3 erhalten wir den folgenden Algorithmus:
Bei AL3º der aus Schritt 4 resultierende Algorithmus. Bei AL4 die Verkettung der Algorithmen AL3º und AL3. Der Algorithmus AL4 kann verwendet werden, um den transparenten BIST zu implementieren. Während des Algorithmus AL3º werden einige der gelesenen Daten invertiert bevor sie in das Signaturregister geführt werden. Diese Invertierung wird durchgeführt, wenn die entsprechenden im Algorithmus AL3 gelesenen Daten gleich dem Inversen des Anfangsinhaltes des RAMs sind. Dann können wir einfach prüfen, daß die erwarteten Signaturen der Algorithmen AL3º und AL3 gleich sind, und der RAM kann durch Vergleich dieser Signaturen geprüft werden. Alternativ dazu können wir die gelesenen Daten von Algorithmus AL3º ohne Invertierung hineinführen und die entsprechenden Daten von AL3 invertieren. Zu beachten ist, daß die letzte Sequenz von AL3º (Sequenz S3º im Beispiel) entfernt werden kann, da die letzte Sequenz von Algorithmus AL3 (Sequenz S3" im Beispiel) vom Blickpunkt der Fehlerüberdeckung nutzlos ist, und wir daher die Signatur während dieser Sequenz nicht zu berechnen brauchen.
Alternativ dazu können wir einen Signatur-Initialisierungs-Algorithmus verwenden, verbunden mit einem Aufwärts-/Abwärts-Signaturregister. Die Reihenfolge der Schritte dieses Algorithmus ist umgekehrt zu denen des Signatunrorhersage-Algorithmus.
Beispiel: durch Umkehrung der Reihenfolge in Algorithmus AL3 erhalten wir den Signatur- Initialisierungs-Algorithmus AL3*:
Offensichtlich ist die Reihenfolge in diesem Algorithmus die Umkehrung der von Algorithmus AL3º. Im Falle des Signatur-Initialisierungs-Algorithmus wird die Ausgabe-Antwort-Kompaktierung durch ein Aufwärts-/Abwärts-Signaturregister durchgeführt (oder allgemeiner durch einen Aufwärts- /Abwärts-Ausgabeantwort-Kompaktierer), der später beschrieben wird. Die Daten, die während des Signatur-Initialisierungs-Algorithmus (AL3*) gelesen wurden, werden in den Aufwärts- /Abwärts-Ausgabeantwort-Kompaktierer geführt. Ähnlich wie beim Signatur-Vorhersage- Algorithmus werden einige Daten von Algorithmus AL3* (oder alternativ einige Daten von Algorithmus AL3) invertiert, bevor sie in den Kompaktierer geführt werden. Die invertierten Daten sind die gleichen wie im Fall des Signatur-Vorhersage-Algorithmus. Während dieser Phase ist der Kompaktierer im Abwärts-Modus (bzw. Aufwärts-Modus). Dann werden die Daten, die beim Grundalgorithmus für den transparenten Test gelesen wurden (Algorithmus AL3) in den Kompaktierer geführt. Während dieser Phase ist der Kompaktierer im Aufwärts-Modus (bzw. Abwärts-Modus). Entsprechend der grundlegenden Eigenschaft der Aufwärts-/Abwärts- Datenkompaktierer (siehe später) ist der Endzustand des Ausgabedaten-Kompaktierers gleich seinem Anfangszustand, und daher vorhersagbar.
Zu beachten ist auch, daß die Signaturvorhersage auf einige alternative Arten durchgeführt werden kann. Zum Beispiel können wir in der Folge R(a1)R(a1) von Sequenz S1º eine Lese- Operation löschen. Diese Modifikation wird ausgeglichen, indem wir das Datum aus der verbliebenen Lese-Operation zweimal in den Ausgabe-Kompaktierer schicken. Somit führen wir immer noch dieselben Daten in den Ausgabe-Kompaktierer sowohl beim Signatur-Vorhersage- Algorithmus als auch beim Grundalgorithmus für den transparenten Test. Natürlich werden wie vorher einige der hineingeführten Daten invertiert. Allgemeiner, wenn der Signatur-Vorhersage- Algorithmus eine Folge von k aufeinanerfolgenden Lese-Operationen auf einer Zelle ci enthält, so können wir in dieser Folge m Lese-Operationen löschen (m < k). Diese Modifikation wird kompensiert, indem k Daten in den Ausgabe-Kompaktierer geführt werden durch die Verwendung der verbleibenden k - m Lese-Operationen. Diese Bemerkung gilt auch für den Signatur- Initialisierungs-Algorithmus.
Schritt 5: Seien bi, ci, di... die Daten, die von Zelle i bei der 2-ten, 3-ten, 4-ten, usw. Lese- Operationen des Algorithmus AL3 gelesen wurden. Da die Daten der Schreib-Operationen bezüglich ai festgelegt wurden, sind die Werte von bi, ci, di,... auch bezüglich a1 festgelegt (d. h. b1 = ai, oder bi = , ci = ai, oder ci = usw.). Danach verwenden wir bi und als Daten in der Folge der Schreib-Operationen, die der zweiten Lese-Operation von Zelle i folgen, ci und als Daten in der Folge der Schreib-Operationen, die der 3-ten Lese-Operation von Zelle i folgen, usw. Wenn zum Beispiel in der Folge der Schreib-Operationen, welche der 2-ten Lese-Operation folgen, das Datum einer Schreib-Operation ai (bzw. ) ist, dann verwenden wir den Wert bi (bzw. ) wenn bi = ai, anderenfalls verwenden wir den Wert (bzw. bi).
Beispiel: durch Anwendung von Schritt 5 auf den Beispiel-Algorithms AL3 erhalten wir den folgenden Algorithmus:
Der durch Schritt 5 erhaltene Algorithmus enthält dieselben erwarteten Werte für alle Lese- und Schreib-Operationen wie der Algorithmus AL3. Dies kann einfach durch Herstellung der Beziehungen zwischen ai und bi, ai und ci, usw. überprüft werden (diese Beziehungen können durch Vergleich der gelesenen Werte in den zwei Algorithmen hergestellt werden). Die Transformation von Schritt S ist von Nutzen, um zu illustrieren, daß wir in jeder Folge von Schreib- Operationen als Schreib-Daten die Daten aus der Lese-Operation verwenden, die der Schreib- Operation vorausgeht (oder ihre Komplemente). Um das zu tun werden die gelesenen Daten in einem Register gespeichert. Diese Transformation hebt auch die Tatsache hervor, daß bei einem fehlerhaften RAM die fehlerhaften Daten, die von einer Zelle gelesen werden, die Daten der darauffolgenden Schreib-Operation der Zelle beeinflussen (während bei einem Standard- Algorithmus die Daten, die bei einer Schreib-Operation verwendet werden, immer korrekt sind). Schritt S wird daher nur aus didaktischen Gründen verwendet.
Bemerkt sei, daß der Grundalgorithmus für den transparenten Test auf verschiedene Weise implementiert werden kann. Zum Beispiel bedeutet die Folge R(a1)W( )R(b1)W( ) der Sequenz S1 "': wir lesen die Zelle C1 und wir speichern den resultierenden Wert a1 in das Testdatenregister, dann schreiben wir in Zelle C1 und benutzen dabei das Inverse des gespeicherten Wertes a1, dann lesen wir C1 und speichern den resultierenden Wert b1 in das Testdatenregister (unter fehlerfreien Bedingungen sollte b1 = sein), und zuletzt schreiben wir das Inverse des gespeicherten Wertes b1 in C1. Alternativ dazu können wir die Folge R(a1)W( )R(b1)W(a1) benutzen. Das heißt, daß wir C1 lesen und den resultierenden Wert a1 in das Testdatenregister speichern, dann schreiben wir in C1 das Inverse des gespeicherten Wertes a1, danach lesen wir C1 (der gelesene Wert b1 wird überwacht, z. B. in den Ausgabedaten- Kompaktierer geführt aber nicht in das Testdatenregister gespeichert), und wir schreiben in C1 den im Testdatenregister gespeicherten Wert (welches im vorliegenden Fall der Wert a1 des ersten Lesens ist). Das heißt, wenn mehrere Lese-Operationen in der Folge von aufeinander folgenden auf eine Zelle i wirkende Operation enthalten sind, können wir nur eine Teilmenge der gelesenen Daten zum Generieren der Schreib-Daten verwenden.
Der auf Algorithmus AL4 basierende transparente BIST kann implementiert werden durch eine Modifizierung der BIST-Schaltung, die für den normalen BIST verwendet wurde, der auf Algorithmus ALin basiert. Ein systematisches Überprüfen der RAM-Testalgorithmen zeigt, daß im allgemeinen die Schritte 0 und 3 nicht notwendig sind. Tatsächlich ist in diesen Algorithmen die erste Operation auf jede adressierte Zelle eine Lese-Operation, und daher ist Schritt 0 nicht notwendig. Diese Koinzidenz kommt von der Tatsache, daß der Beginn mit einer Lese-Operation sehr effizient besonders für Kopplungsfehler und Muster-abhängige Fehler ist, welche die vorherrschenden Fehler in RAMs sind. Dies ist deshalb so, weil wenn man mit einer Schreib- Operation beginnt, dann verliert man die Wirkung, den vorausgehende Übergänge in anderen Zellen oder die besonderen Muster, die zuvor in anderen Zellen enthalten waren auf die fehlerhaften Zellen haben. Auf der anderen Seite zeigt das Überprüfen der bekannten Algorithmen, daß, wenn man die Initialisierungs-Sequenz (bzw. die Initialisierungs-Operationen) löscht, dann enthalten diese Algorithmen dieselbe Anzahl von 0 -> 1 und 1 -> 0 Transitionen. Diese Tatsache impliziert, daß am Ende von Schritt 2 der RAM-Inhalt gleich seinem Anfangsinhalt ist und Schritt 3 nicht benötigt wird. Diese Tatsache kommt von einer Symmetrieeigenschaft des RAM- Fehlermodells bezüglich des 0- und 1-Inhalts jeder Zelle und bezüglich der 0 -> 1 und 1 -> 0 Übergänge. Diese Eigenschaft wird später vorgestellt.
Nach der obigen Diskussion können wir sehen, daß die Sequenzierung von Algorithmus AL3 ein wenig komplexer als die Sequenzierung des Algorithmus ALin ist, und so ist es auch mit der BIST-Schaltung. Auf der anderen Seite ist der Algorithmus AL3º aus AL3 durch Löschen der Schreib-Operationen hervorgegangen. Daher können wir die gleiche BIST-Schaltung wie für Algorithmus AL3 verwenden, wobei wir aber bei der Ausführung von AL3º die Schreib-Operationen blockieren. Dies wird später für den transparenten BIST entsprechend Marinescus Algorithmus illustriert, wobei eine einfache Modifikation des Zeitpunkt-Generators verwendet wird. Wir schließen daraus, daß die transparenten BIST-Schaltung etwas komplexer sein wird als die für den normalen BIST. Ähnlich kann der Algorithmus AL3* nach einigen leichten Modifikationen erhalten werden, durch Verwendung der Schaltung, die den Algorithmus AL3 generiert.
Die offene Frage ist jetzt die Fehlerüberdeckung, die durch den transparenten BIST geboten wird. Im folgenden zeigen wir, daß für die Mehrzahl der bekannten RAM-Fehlermodelle die Fehlerüberdeckung die gleiche ist wie für den ursprünglichen Algorithmus. Bei dieser Analyse berücksichtigen wir nicht das Maskierungsproblem, mit dem die Verwendung eines Ausgabeantwort-Kompaktierers behaftet ist, welches fast allen BIST-Anordnungen gemein ist.
Lemma 1: Die Schritte 0 und 4 verändern nicht die Fehlerüberdeckung des Algorithmus. Dieses Lemma gilt, weil für alle bekannten Fehlermodelle die Lese-Operationen keine Modifikationen des Wertes einer RAM-Zelle bewirken (z. B. siehe die zuvor vorgestellten RAM- Fehlermodelle). Auf der anderen Seite fügen die Schritte 0 und 4 nur Lese-Operationen zum Algorithmus hinzu.
Lemma 2: Der Schritt 3 verändert nicht die Fehlerüberdeckung des Algorithmus. Dieses Lemma gilt, weil der Schritt 3 einige zusätzliche Lese- und Schreib-Operationen nach dem Ende des Grundalgorithmus ausführt, daher, wenn ein Fehler eine fehlerhafte Ausgabe beim Grundalgorithmus erzeugt, können die neuen Operationen ihn nicht maskieren.
Ein anderes Problem kommt von der Tatsache, daß die Signatur von Algorithmus AL3' nicht bezüglich einer vorberechneten Signatur geprüft wird sondern bezüglich eine Signatur, die aus vom RAM selbst generierten Daten berechnet wurde (d. h. Algorithmus AL3º). Daher kann man annehmen, daß einige Fehler im RAM die gleichen fehlerhaften Ausgaben sowohl bei AL3 als auch bei AL3º erzeugen (oder sowohl bei AL3 als auch bei AL3*), und der Fehler wird daher maskiert, so wie es im Fall von Koenemans Verfahren passiert. Das folgende Lemma kommt mit diesem Problem klar.
Lemma 3: Der Vergleich der Signaturen, die bei den Algorithmen AL30 und AL3 generiert werden, kann die Erkennung eines Fehlers nicht maskieren.
Beweis: Bei ai das Datum, das beim ersten Mal durch Algorithmus AL3º in einer Zelle ci gelesen wurde. Für alle bekannten RAM-Fehlermodelle kann die Lese-Operation von irgendwelchen Zellen ck1, ck2,... ckr nicht den Wert des Datums, das von irgendeiner anderen Zelle ci gelesen wird, verändern. Da der Algorithmus AL3º nur Lese-Operationen ausführt, wird jedesmal, wenn wir die Zelle ci während des Algorithmus AL3º lesen, der gelesene Wert ai sein, und dies gilt für jede Zelle ci des RAMs. Wenn der Algorithmus AL3 einen Fehler erkennt (das bedeutet, daß der zu einem bestimmten Zeitpunkt von AL3 gelesene Wert einer Zelle ci sich vom erwarteten Wert a1 oder unterscheidet), dann führen wir bei den Algorithmen AL3º und AL3 unterschiedliche Daten in den Ausgabeantwort-Kompaktierer. Q. E. D.
Lemma 4: Die Signaturprüfungs-Anordnung, die den Signatur-Initialisierungs-Algorithmus AL3* und einen Aufwärts-/Abwärts-Ausgabedaten-Kompaktierer verwendet, kann nicht die Erkennung eines Fehlers maskieren.
Beweis: Dieses Lemma kann ähnlich wie Lemma 3 bewiesen werden.
Natürlich betrachten wir in den obigen Lemmata nicht das Maskierungsproblem (d. h. der Ausgabeantwort-Kompaktierer gibt die gleiche Signatur für sowohl die erwartete Antwortausgabe als auch für die fehlerhafte Antwortausgabe von Algorithmus AL3 aus). Diese Problem betrifft jede Anordnung, die eine Ausgabeantwort-Kompaktierung durchführt und ist nicht spezifisch für den transparenten BIST.
Im folgenden geben wir einige sehr allgemeine Resultate an, die es leicht zu prüfen erlauben, ob der Schritt 2 die Fehlerüberdeckung des Originalalgorithmus beeinflußt. Zuerst geben wir eine Symmetrieeigenschaft an, die der Mehrzahl der RAM-Fehlermodelle innewohnt. Diese Eigenschaft ist sehr wichtig, weil, wie wir später in Theorem 1 zeigen, wenn das Fehlermodell diese Eigenschaft erfüllt, dann verringert der Schritt 2 nicht die Fehlerüberdeckung des Algorithmus.
Symmetrieeigenschaft (SE): Bei F ein Fehlermodell und sei f F ein Fehler, welcher die Zustände s&sub1;, s&sub2;,..., sk1 der Zellen C&sub1;, C&sub2;,..., Ck1 und die Übergänge tk1+1, tk1+2,..., tk1+k2 der Zellen Ck1+1, Ck1+2,..., Ck1+k2 beinhaltet. Dann gehören die Fehler, die aus f durch Invertierung einer Zusammenstellung von Zuständen aus s&sub1;, s&sub2;,..., sk1 und einer Zusammenstellung von Übergängen aus tk1+1, tk1+2,..., tk1+k2 abgeleitet sind, zum Fehlermodell F.
Im folgenden werden wir zeigen, daß diese Eigenschaft von allen bekannten RAM-Fehlermodellen erfüllt wird. Diese Fehlermodelle wurden zuvor vorgestellt.
Für einfache Haftfehler transformieren die von der Symmetrieeigenschaft betroffenen Transformationen einen Haftfehler 0 in einen Haftfehler 1 und einen Haftfehler 1 in einen Haftfehler 0, welches beides Haftfehler sind. Es ist auch offensichtlich, daß jede Zusammenstellung von Transformationen, die von der SE betroffen sind, einen mehrfachen Haftfehler in einen anderen mehrfachen Haftfehler transformieren. Daher gilt die Eigenschaft für das Einfach- und Mehrfach- Haftfehlermodell. Ein Übergangsfehler, welcher den Übergang S - einer Zelle beinhaltet wird in einen Übergangsfehler transformiert, welcher den Übergang - S der gleichen Zelle beinhaltet. Dann wird die Anwendung jeder Zusammenstellung von Transformationen, die von der SE betroffen ist, auf einen Mehrfach-Übergangsfehler einige diese Übergangsfehler in andere Übergangsfehler transformieren und andere Übergangsfehler unverändert lassen. Somit gilt die SE für Einfach- und Mehrfach-Übergangsfehler.
Die Anwendung irgendeiner Zusammenstellung von Transformationen, die von der SE betroffen sind, auf einen Kopplungsfehler T(is,jt) ergibt einen Kopplungsfehler T(is',jt'). Die Anwendung irgendeiner Zusammenstellung dieser Transformationen auf einen Mehrfach-Kopplungsfehler wird einige diese Kopplungsfehler in andere Kopplungsfehler modifizieren und andere Kopplungsfehler unverändert lassen. Der resultierende Fehler ist ein Mehrfach-Kopplungsfehler. Somit erfüllen Einfach- und Mehrfach-Kopplungsfehler die SE.
Ähnlich wird eine Zusammensetzung von Transformationen, die von der SE betroffen sind, angewandt auf einen ANPSF-Fehler AN(is, jt,1s1,2s2,...,ksk), diesen in einen Fehler AN(is', jt', 1s1', 2s2', ksk') transformieren, der zum Fehlermodell gehört. Dies kann leicht auf Mehrfach- ANPSF-Fehler ausgedehnt werden. Somit gilt die SE für das einfache und mehrfache Aktive Muster-abhängige Fehlermodell.
Die Anwendung einer Zusammensetzung von Transformationen, die von der SE betroffen sind, auf einen passiven Muster-abhängigen Fehler PN(is, 1s1,2s2,...,ksk) ergibt einen passiven Muster- abhängigen Fehler PN(is', 1s1', 2s2',..., ksk'). Dies kann leicht auf mehrfache passive Muster- abhängige Fehler ausgedehnt werden. Somit gilt die SE für das einfache und mehrfache Passive Muster-abhängige Fehlermodell.
Dann kann man leicht prüfen, daß ein Fehlermodell, das einige der obigen Fehlermodelle kombiniert, die Symmetrieeigenschaft erfüllt.
Ähnliche Argumente können verwendet werden für die einfachen und mehrfachen statischen und dynamischen Muster-abhängigen Fehlermodelle, definiert in "SALUJA K. K., KINOSHITA K. - "Test pattern generation for API faults in RAM, IEEE Transactions on Computers, C-34, 3, März 1985", und für die einfachen und mehrfachen komplexen Kopplungs- und gleichzeitig auftretende Kopplungsfehler-Modelle, die kürzlich für Multiport-RAMs in "CASTRO ALVES V., NICOLAIDIS M, LESTRAT P., COURTOIS B., "Built-In Self-Test for Multi-Port RAMs", Proc. ICCAD, Santa Clara, November 1991" eingeführt wurden. Allgemeiner bemerken wir, daß die Transformationen, die von der Symmetrieeigenschaft betroffen sind, nur die am Fehler beteiligten einzelnen Werte der Zustände oder der Übergänge verändern und somit einen Fehler von derselben Natur wie der originale produzieren. Somit ist das Fehlermodell in sich abgeschlossen, denn, ausgehend von einem Fehler des Fehlermodells erzeugt die Anwendung einer Transformation, die von der Symmetrieeigenschaft betroffen ist, einen Fehler, der zum Fehlermodell gehört. Somit gilt die folgende Behauptung.
Behauptung 1: Die Symmetrieeigenschaft wird von den in sich abgeschlossenen RAM- Fehlermodellen erfüllt.
Die obigen Fehlermodelle sind in sich abgeschlossen (z. B. enthält das Kopplungs-Fehlermodell alle Kopplungsfehler). Wenn das Fehlermodell jedoch reduziert wird, kann die Symmetrieeigenschaft verloren gehen. Wenn das Fehlermodell zum Beispiel den Kopplungsfehler T(i0, jt) enthält, jedoch nicht den Fehler T(i1, jt), dann gilt die SE nicht. Einige in der Literatur vorgeschlagenen Fehlermodelle sind reduziert, entweder, weil die Algorithmen, die für das in sich abgeschlossene Fehlermodell erforderlich sind, sehr komplex sind oder weil einige Fehler des Modells unrealistisch sind.
Für die Mehrzahl der in der Literatur verwendeten reduzierten Fehlermodelle gilt die SE jedoch noch. Der Grund dafür ist, daß keiner der Zustände 0 und 1 und der Übergänge 0-> 1 and 1-> 0 als bedeutsamer betrachtet wird als der andere. Die obige Diskussion wird veranschaulicht durch zwei bekannte reduzierte Fehlermodelle. Der eine behält die SE, während der andere es nicht tut. Ein wichtiges reduziertes Fehlermodell ist das Kopplungsfehler-Modell, welches in "Marinescu M. "Simple and efficient algorithms for functional RAM testing", IEEE International Test Conference, November 1982" betrachtet wird, und welches die invertierenden Kopplungsfehler ausschließt. Diese Reduktion kann durch die Tatsache gerechtfertigt werden, daß invertierende Kopplungsfehler sehr komplexe Testalgorithmen erforden, wobei diese Fehler unrealistisch sind. Präziser umfaß dieser Artikel Einfach- und Mehrfach-Kopplungsfehler, aber er schließt solche mehrfachen aus, die sowohl den Fehler T(i0, jt) als auch T(i1, jt) enthalten (d. h. er schließ die invertierenden Kopplungsfehler aus). Wir werden zeigen, daß die SE für dieses Modell gilt: Wenn die Transformationen, die mit der SE in Zusammenhang stehen, auf nicht-invertierende Kopplungsfehler angewendet werden, so erzeugen sie niemals invertierende Kopplungsfehler (d. h. einen Mehrfachfehler, der die beiden Fehler T(is1', jt1') und T(is2', jt2') enthält, so daß s1' = s2' und t1' = t2'). Der ursprüngliche Fehler muß zwei Fehler T(is1, jt1) und T(1s2, jt2) enthalten, anderenfalls wird die Transformation, die von der SE betroffen sit, niemals einen der oben erwähnten Fehler erzeugen. Da der Ausgangsfehler zum Fehlermodell gehört, können wir nicht s1 = s2 t1 = t2 haben. Ausgehend von den Transformationen, die von der SE betroffen sind und welche den Fehler T(is1', jt1') & T(is2', jt2') Produzieren, haven wir:
(s&sub1;' = s&sub1; s&sub2;' = s&sub2;) s&sub1;' = s&sub2;' = ) und (t&sub1;' = t&sub1; t&sub2;' = t&sub2;) (t&sub1;' = t&sub2;' = ).
Durch diese Beziehungen und dadurch, daß wir nicht s1 = s2 und t1 = t2 haben können, finden wir leicht, daß wir niemals s1' = s2' t1' = t2' haben können. Dann gehören die Fehler, die von Transformationen resultieren, die von der SE betroffenen sind, zum Fehlermodell, und die SE ist gültig.
Eine ähnliche Argumentation kann verwendet werden für das einfache und mehrfache komplexe Kopplungsfehlermodell, welches durch das Entfernen von invertierenden komplexen Kopplungsfehler reduziert wurde, wie in "CASTRO ALVES V., NICOLAIDIS M, LESTRAT P., COURTOIS B., "Built-In Self-Test for Multi-Port RAMs", Proc. ICCAD, Santa Clara, November 1991 " betrachtet.
"Papachristou C. A., Sahgal N. B., "An Improved Method for Detecting Functional Faults in Semiconductor Random Access Memories", IEEE Transactions on Computers, Vol. C-27, S. 572- 576, Juni 1978" betrachtet ein anderes reduziertes Modell von Kopplungsfehlern. In diesem Artikel werden die wechselwirkende Kopplungsfehler ausgeschlossen. Wechselwirkende Kopplungsfehler genannt werden die mehrfachen Kopplungsfehler T(is1, jt1) & T(is2, kt2) so daß t1 = t2 und s1 = s2. Wir bemerken, daß der Fehler T(is, jt) & T(is, kt) nicht wechselwirkend ist. Dann erhalten wir, wenn wir auf diesen Fehler die Transformation anwenden, die die Übergänge der Zelle k invertiert, den Fehler T(is, jt) & T(is, kt), welcher wechselwirkend ist. Somit bricht das Entfernen der wechselwirkenden Kopplungsfehler die Symmetrie. Die SE gilt nicht für dieses Modell. In diesem Fall ist nicht garantiert, daß der transparente Testalgorithmus dieselbe Fehlerüberdeckung bietet wie der ursprüngliche Algorithmus. Wir schließen, daß der transparente BIST für Kopplungsfehler auf Marinescus Algorithmus basieren muß. Das ist jedoch keine bedeutende Einschränkung - der Algorithmus von Marinescu scheint effizienter für Kopplungsfehler zu sein. Tatsächlich ist es, wie wir erläutert haben, vernünftig, daß invertierende Kopplungsfehler nicht auftreten können (d. h. beide Fehler T(is, jt) und T(is, jt) können nicht auftreten), aber es gibt keinen besonderen Grund anzunehmen, daß wechselwirkende Fehler nicht auftreten können (d. h. beide Fehler T(is, jt) und T(is, kt), j k nicht auftreten können).
Durch die obige Diskussion haben wir folgende Behauptung:
Behauptung 2: Einige Reduktionen des RAM-Fehlermodells kann die Symmetrieeigenschaft brechen.
Ein verbreiteter Typ von Reduktion ist der der topologischen. Diese Reduktion entfernt alle Fehler, welche Interaktionen zwischen Zellen beinhalten, die keine Nachbarn sind. Dies ist eine realistische Reduktion und wird oft im Fall von Fehlern verwendet, für die das in sich abgeschlossene Fehlermodell sehr komplexe Testalgorithmen bedingt (z. B. das wohlbekannte Muster-abhängige Fehlermodell und das neuere komplexe Kopplungsfehlermodell "CASTRO ALVES V., NICOLAIDIS M, LESTRAT P., COURTOIS B., "Built-In Self-Test for Multi-Port RAMs", Proc. ICCAD, Santa Clara, November 1991"). Wir merken an, daß, wenn man eine der von der Symmetrieeigenschaft betroffenen Transformationen auf einen Fehler f anwendet, dann beinhaltet der resultierende Fehler f' keine Interaktionen zwischen Zellen, für die auch der Fehler f keine Interaktionen beinhaltet. Deshalb, wenn der Fehler f Interaktionen nur von Nachbarzellen beinhaltet, so trifft das auch auf f' zu. Somit haben wir die folgende Behauptung.
Behauptung 3: Wenn das ursprüngliche Fehlermodell die Symmetrieeigenschaft erfüllt, dann wird auch das Fehlermodell, das durch eine topologische Reduktion erzeugt wurde, diese Eigenschaft erfüllen.
Insbesondere die topologische Reduktion des einfachen und mehrfachen Muster-abhängigen Fehlermodells ergibt ein Fehlermodell, welches die Symmetrieeigenschaft erfüllt. Auch das einfache und mehrfache komplexe Kopplungsfehlermodell, welches sich aus der Beseitigung der invertierenden komplexen Kopplungsfehler und der Anwendung der topologischen Reduktion ergibt (wie in "CASTRO ALVES V., NICOLAIDIS M, LESTRAT P., COURTOIS B., "Built-In Self- Test for Multi-Port RAMs", Proc. ICCAD, Santa Clara, November 1991 "), erfüllt die Symmetrieeigenschaft. Somit verringert der transparente BIST nicht die Fehlerüberdeckung für diese Fehlermodelle.
Jetzt geben wir Theorem 1 an.
Theorem 1: Wenn das Fehlermodell die Symmetrieeigenschaft erfüllt, dann verringert der Algorithmus, der sich nach der Anwendung der Schritte 0, 1 und 2 ergibt, nicht die Fehlerüberdeckung des ursprünglichen Algorithmus.
Beweis: Betrachten wir ein RAM-Fehlermodell F, welches die SE erfüllt, und einen Testalgorithmus ALin, welcher eine Abdeckung von a% für dieses Modell bietet. Wenden wir die Schritte 0, 1 und 2 auf diesen Algorithmus an, und sei AL der Algorithmus, der aus Schritt 0 resultiert und sei AL' der resultierende Algorithmus nach Schritt 2. Wie in Lemma 1 gezeigt wurde, verringert der Schritt 0 nicht die Fehlerüberdeckung des ursprünglichen Algorithmus. Somit haben wir die Abdeckung der Algorithmen AL und AL' zu vergleichen.
Wenn Schritt 1 die Initialisierungs-Sequenz (bzw. die Initialisierungs-Operationen) löscht, dann ist diese Sequenz (bzw. sind diese Operationen) nutzlos vom Standpunkt der Fehleranregung. Somit, wenn wir im folgenden die Zustände und Übergänge der Algorithmen AL und AL' vergleichen, betrachten wir nicht die Zustände und Übergänge, die bei dieser Sequenz vorkommen.
Wenn Schritt 1 die Initialisierungs-Sequenz (bzw. die Initialisierungs-Operationen) nicht löscht, dann sind im ursprünglichen Algorithmus ALin die in der Initialisierung-Sequenz enthaltenen Übergänge unbestimmt (weil vor diesen Operationen der Inhalt des RAMs unbekannt ist). Somit können diese Übergänge vom Standpunkt der Fehleranregung nicht brauchbar sein. Wenn wir im folgenden die Übergänge der Algorithmen AL und AL' vergleichen, werden wir diese Übergänge nicht betrachten.
Seien 1,2,3,...,n die Speicherzellen und a1, a2, a3,..., an ihre Anfängszustände. Bei ak der Anfangszustand einer Zelle k, und sei rk das Datum aus der ersten Lese-Operation in Sequenz S1' von Algorithmus AL0. Wenn (im Fall a- von Schritt 2) ak = 0, oder wenn (im Fall b- von Schritt 2) ak = rk, dann erhält Schritt 2 die Zustands- und Übergangswerte (der Zelle k), die in Algorithmus AL involviert sind, anderenfalls invertiert Schritt 2 all diese Zustands- und Übergangswerte. Betrachten wir einen zu F gehörenden Fehler f, der von AL erkennbar ist und die Zustände sk1, sk2,...,sk1 in den Zellen k1, k2,..., k1 und die Übergänge tki+1, tki+2,..., tki+j in den Zellen ki+1, ki+2,..., ki+j einschließt. Seien ak1, ak2,..., akj, akj+1, akj+2,..., akj+j die Anfangszustände dieser Zellen. Es ist für einen Fehler möglich, daß die Mengen S = {k1,k2,...,k1} und T = {ki+1, ki+2,..., ki+j} einige gemeinsame Elemente haben. - In der obigen Beschreibung ziehen wir auch in Betracht, daß diese Mengen einige doppelte Elemente haben können. Dies ist so, weil ein Mehrfachfehler sowohl den Zustand 0 als auch 1 oder sowohl den Übergang 0 → 1 als auch 1 → 0 einer Zelle umfassen kann. - Betrachten wir nun einen Fehler f', derart, daß å q S: wenn (im Fall a- von Schritt 2) ak = 0, oder wenn (im Fall b- von Schritt 2) ak = rk, dann umfaßt f' den Zustand sq' = sq, anderenfalls umfaßt f' den Zustand sq' = sq, und derart, daß å p T: wenn (im Fall a- von Schritt 2) ap = 0, oder wenn (im Fall b- von Schritt 2) ap = rp, dann umfaßt f' den Übergang tp' = tp, anderenfalls umfaßt f' den Übergang tp' = tp.
Das erste Element des Beweises ist offensichtlich: die obige Abbildung bildet niemals zwei unterschiedliche Fehler f1 und f2 auf denselben Fehler f' ab.
Das zweite Element dieses Beweises ist, daß AL' f' erkennt: Wir merken an, daß die Erkennung der Fehler f und f' nicht berührt wird durch die Zustände von Zellen, die nicht zu S gehören und durch die Übergänge von Zellen, die nicht zu T gehören. Somit müssen wir nicht auf die Modifikationen der Zustände und Übergänge achten, die in Schritt 2 diese Zellen einschließen. Dann merken wir an, daß beide Transformationen f -> f' und AL -> AL' dieselben Modifikationen auf den Zuständen der Menge S und auf den Übergängen der Menge T beinhalten. Somit können wir schließen, daß, wenn AL f erkennt, dann erkennt AL' f'. Es gibt jedoch eine hintergründige Bemerkung zu dieser Behauptung. Die Modifikationen auf den erwähnten Zuständen und Übergängen, die von AL -> AL' betroffen sind, sind die gleichen wie die, die von f -> f' betroffen sind, wenn die Algorithmen auf einen fehlerfreien RAM ausgeführt werden. In einem fehlerhaften RAM werden die Daten, die bei Algorithmus AL geschrieben werden, extern generiert (somit sind sie gleich den Daten, die durch den Algorithmus AL definiert werden), während die Daten, die bei Algorithmus AL' geschrieben werden, die Daten sind, die vom RAM gelesen wurden, und können unterschiedlich für den fehlerfreien und für den fehlerhaften RAM sein (diese Situation wird klarer, wenn man den Algorithmus betrachtet, der aus Schritt S resultiert). Somit kann in einem fehlerhaften RAM die Korrespondenz zwischen den Transformationen AL -> AL' und f -> f' verloren gehen. Dieses Problem kann jedoch nicht die Erkennung von f' verhindern. Der Grund ist folgender: wenn der Algorithmus AL' ein unkorrektes Datum schreibt, so ist dies auch ein unkorrekt gelesenes Datum. Somit erkennt AL' f' wiederum. Da f zu F gehört und F die Symmetrieeigenschaft erfüllt, gehört f' auch zu F.
Auf ähnliche Weise können wir zeigen, daß jeder Fehler f', der zu F gehört und durch AL' erkannt wird, genau einem Fehler f, der zu F gehört, entspricht und von AL erkannt wird. Somit gibt es eine eins-zu-eins-Korrespondenz zwischen den Fehlern, die durch die beiden Algorithmen erkannt werden, so daß sie die gleiche Anzahl von Fehlern des Fehlermodells F erkennen und sie somit die gleiche Fehlerüberdeckung (a%) bieten. Speziell, wenn der ursprüngliche Algorithmus alle Fehler des Modells erkennt, so wird der Algorithmus, der sich nach den Schritten 0, 1 und 2 ergibt, auch alle Fehler erkennen. Q. E. D.
Folgerung 1: Wenn das Fehlermodell die Symmetrieeigenschaft erfüllt, dann verringert der Algorithmus, der sich ergibt, indem alle Daten einer gegebenen Menge von Zellen, die im RAM- Testalgorithmus verwendet werden, invertiert werden, nicht die Fehlerüberdeckung des ursprünglichen Algorithmus.
Diese Folgerung erhält man leicht aus dem Beweis von Theorem 1.
Abschließend zeigen wir im folgenden Theorem, daß die Erfüllung der Symmetrieeigenschaft notwendig ist, um sicherzustellen, daß es keine Verringerung der Fehlerüberdeckung gibt.
Theorem 2: Wenn das Fehlermodell, das durch den RAM-Testalgorithmus AL abgeckt wird, die Symmetrieeigenschaft nicht erfüllt, dann verringert der resultierende transparente Testalgorithmus die Fehlerüberdeckung.
Beweis: Ausgehend von Theorem 2 gibt es mindestens zwei Fehler f und f', so daß: a - f ist abgedeckt durch den Testalgorithmus AL,
b - es gibt eine Menge von Transformationen, die von der Symmetrieeigenschaft betroffen sind, welche den Fehler f in f' transformiert,
c - der Fehler f' wird durch den Testalgorithmus AL nicht erkannt.
Sei AL' der Algorithmus, der sich aus Schritt 2 ergibt. Dann können wir durch Benutzung der Ideen aus dem Beweis von Theorem 1 einen Anfangszustand des RAM's derart finden, daß beide Transformationen f'-> f und AL-> AL' die gleichen Zustands- und Übergangsmodifikationen beinhalten. Dann können wir durch eine Argumentation, ähnlich der des Beweises von Theorem 1, einfach prüfen, daß gilt: f' ist nicht erkennbar durch AL impliziert, daß f nicht durch AL' erkennbar ist. Da der RAM einen beliebigen Anfangsinhalt haben kann, sichert der transparente Testalgortihmus nicht die Abdeckung des Fehlers f. Q. E. D.
Von den Lemmata 1, 2, 3 und 4 und Theorem 1 ist es offensichtlich, daß gilt: wenn das Fehlermodell die Symmetrieeigenschaft erfüllt, dann verringert der transparente Testalgorithmus, der in diesem Artikel hergeleitet wurde, nicht die Fehlerüberdeckung der Standard-RAM- Testalgorithmen. Zum Beispiel verändert die transparente BIST-Implementierung, die unten dargestellt wird und auf Marinescus Algorithmus basiert, nicht die Fehlerüberdeckung des ursprünglichen Algorithmus.

Die inversen Transformationen:

Nehmen wir an, jemand besitzt einen transparenten RAM-Testalgorithmus kennt aber nicht den den Standard-RAM-Testalgorithmus, von dem er abgeleitet wurde. Die inversen Transformation gestatten, die Menge von Standard-Algorithmen, von denen der transparente abgeleitet wurde, zu bestimmen.
Betrachten wir einen transparenten RAM-Testalgorithmus, welcher nur aus dem Grundalgorithmus besteht (die Signatur-Vorhersage-Sequenzen wurden weggelassen).
Nehmen wir an, daß die Daten, die bei den Schreib-Operationen des transparenten Testalgorithmus verwendet wurden, das Datum ai, das aus der ersten Lese-Operation von der Zelle i resultiert, und sein Inverses sind (wie zum Beispiel in den Algorithmen, die durch die Transformationsschritt 0, 1, 2 und 3 abgeleitet wurden).
Schritt 2: Dieser Schritt führt die inverse Transformation zu Schritt 2 aus, das heißt, wir ersetzen die Variablen ai durch 0 und die Variable durch 1. Alternativ dazu können wir die duale Transformation verwenden (d. h. wir ersetzen ai durch 1 und durch 0).
Schritt 0: Im Algorithmus, der aus dem obigen Schritt resultiert, sei eine Folge von Operation die Menge von Operationen, die erfolgreich auf eine Zelle i angewendet wurde. Betrachten wir die Menge von Folgen, die mit einer Lese-Operation beginnen. Entferne jede Zusammenstellung dieser Lese-Operationen, um einen neuen Algorithmus zu erhalten. Dieser Schritt ist der inverse zu Schritt 0. Wir erhalten verschiedene Algorithmen entsprechend der Zusammenstellung der entfernten Lese-Operationen.
Schritt 1: Betrachten wir den Algorithmus, der sich aus Schritt ergibt, oder einen Algorithmus, der sich ergibt durch Anwendung von Schritt , gefolgt von Schritt . Wenn im betrachteten Algorithmus die erste Operation auf einigen Zelle eine Lese-Operation ist, dann füge eine Initialisierung-Sequenz hinzu. Alternativ dazu, füge eine Initialisierungs-Operation (d. h. eine Schreib-Operation) vor jeder dieser Lese-Operationen hinzu. Die Initialisierungs-Sequenz setzt sich zusammen aus einer Menge von Schreib-Operationen, welche gestatten, die Zustände der Speicherzellen auf die für die erste Lese-Operation erwarteten Werte zu setzen. Dieser Schritt ist der inverse zu Schritt 1.
Die Algorithmen, die aus der Anwendung von Schritt resultieren, sind Standard-RAM- Testalgorithmen (d. h. sie verwenden die bekannten Binärwerte 0 und 1).
Schritt 3: Betrachten wir den Algorithmus, der sich aus der Anwendung von Schritt gefolgt von Schritt ergibt, oder einen Algorithmus, der aus der Anwendung von Schritt , gefolgt von Schritt , gefolgt von Schritt resultiert. Wenn eine Folge von Operationen, die eine Zelle betreffen und die in der letzten Sequenz des Algorithmus enthalten sind, aus einer Lese- Operation, gefolgt von einer Schreib-Operation bestehen, dann entferne jede Zusammenstellung solcher Folgen. Dieser Schritt ist der inverse zu Schritt 3. Wir erhalten verschiedene Algorithmen, entsprechend der Zusammenstellung der entfernten Folgen.
Schritt 5: Dieser Schritt ist der inverse zu Schritt 5. Betrachten wir einen Algorithmus (wie beispielsweise den, der durch Schritt 5 der direkten Transformationen abgeleitet wurde), der dadurch beschrieben ist, daß für jede Schreib-Operation einer Zelle i die Daten (oder die inversen Daten) der letzten Lese-Operation von der Zelle i, die der Schreib-Operation vorangeht, verwendet werden. Das bedeutet, daß die Schreib-Operationen die Daten ai, bi, ci, di, usw. der ersten, zweiten, dritten, vierten usw. Lese-Operationen und ihre Inversen , , , usw. verwenden. Da die Schreib-Operationen, die der ersten Lese-Operation folgen, die Werte oder verwenden, kann man den Wert bi der zweiten Lese-Operation bezüglich ai bestimmen (d. h. bi = ai oder bi = ). Auf dieselbe Weise kann man den Wert von ci bezüglich ai bestimmen und so weiter. Damit besteht Schritt aus dem Ersetzen der Werte bi, , ci, , di, , usw. durch die Werte ai, wie zuvor festgelegt.
Der Algorithmus, erhalten durch die Anwendung von Schritt , gefolgt von Schritt (oder durch Anwendung von Schritt , gefolgt von den Schritten und ) wird der abdeckende nicht- transparente Algorithmus genannt. Die Algorithmen, erhalten durch Anwenden der Schritte , , oder der Schitte , , oder der Schritte , , , (oder durch Anwendung von Schritt , gefolgt von diesen Schritten), werden die abgedeckten nicht-transparenten Algorithmen genannt.
Die Fehlerüberdeckung kann einfacher für einen Standard-RAM-Testalgorithmus bestimmt werden als für einen transparenten. Wenn jemand einen transparenten Testalgorithmus besitzt, aber nicht den Standard-Algorithmus kennt, von dem dieser abgeleitet wurde, so kann er, um die Fehlerüberdeckung des transparenten zu bestimmen, zuerst die Fehlerüberdeckung des abdeckenden Standard-Testalgorithmus bestimmen (d. h. desjenigen, der durch Anwendung von Schritt , gefolgt von Schritt wie oben abgeleitet wurde).
Wenn das Fehlermodell die Symmetrieeigenschaft erfüllt, so können wir aus dem Beweis von Theorem 1 leicht ableiten, daß der abdeckende Algorithmus und der transparente die gleiche Fehlerüberdeckung haben. Somit bestimmen wir die Fehlerüberdeckung des transparenten Testalgorithmus.

Beispiel:

Ein Beispiel eines transparenten Testalgorithms, der unter Verwendung unseres Verfahrens hergeleitet wurde, und seine BIST-Implementierung werden im folgenden auf der Basis von Marinescus RAM-Testalgorithmus vorgestellt. Der Algorithmus B (angegeben in Marinescu M. "Simple and efficient algorithms for functional RAM testing", IEEE International Test Conference, November 1982) ist in Tabelle I angegeben. Dieser Algorithmus führt 17.n Lese- und Schreib- Operationen durch (n ist die RAM-Größe), und deckt alle einfachen und mehrfachen Haftfehler und alle idempotenten Kopplungsfehler ab. Tabelle I: Algorithmus B von Marinescu.
Der obige Algorithmus betrachtet Bit-orientierte RAMs. Im Fall von Wort-orientierten RAMs schreibt man gleichzeitig in mehrere RAM-Zellen. Somit können einige neue Fehler auftreten. Wenn wir zum Beispiel gleichzeitige Übergänge in zwei Zellen ci und cj ausführen, so können diese Übergänge den Wert einer dritten Zelle ck verändern. Wir nennen diese Fehler komplexe Kopplungsfehler "CASTRO ALVES V., NICOLAIDIS M, LESTRAT P., COURTOIS B., "Built-In Self- Test for Multi-Port RAMs", Proc. ICCAD, Santa Clara, November 1991 ". Ebenso, wenn wir gleichzeitige Übergänge in zwei Zellen ci und cj ausführen, kann der Übergang einer Zelle den Übergang der anderen Zelle verhindern. Dieser Fehler wird gleichzeitiger Kopplungsfehler genannt "CASTRO ALVES V., NICOLAIDIS M, LESTRAT P., COURTOIS B., "Built-In Self-Test for Multi- Port RAMs", Proc. ICCAD, Santa Clara, November 1991 ". Diese Fehler können zum Beispiel auftreten im Fall, wo jede RAM-Zeile ein einzelnes Wort implementiert, wie in Fig. 1a. In dieser Figur sehen wir, daß eine Zelle eines Wortes (z. B. Wort b) drei Nachbarzellen hat, die zu einem anderen Wort gehören (z. B. Wort a). Somit müssen wir den RAM für acht mögliche Übergänge (d. h. 000 --> 111, 111 --> 000, 001 --> 110, 110--> 001, 010 --> 101, 101 --> 010, 011 --> 100, und 100 --> 011) von allen drei aufeinander folgenden Zellen jedes Wortes testen. Dies kann gemacht werden durch viermalige Ausführung des Algorithmus von Tabelle I und jedesmal durch Verwendung eines der folgenden Datenpaare (000000...000..., 111111...111...), (001001...001..., 110110...110...), (010010...010..., 101101...101...), und (011011...011..., 100100...100...). Wurde der RAM unter Verwendung eines 1-aus-2-Multiplexen der Spalten implementiert, so implementiert jede Zeile des RAM's zwei Wörter, wie in Fig. 1b gezeigt. Wir merken an, daß in diesem Fall eine Zelle eines Wortes (d. h. Wort a) höchstens zwei Nachbarzellen haben kann, die zu einem anderen Wort (d. h. Wort c) gehören. Somit müssen wir den RAM für vier mögliche Übergänge (d. h. 00 --> 11, 11 --> 00, 01 --> 10, 10 --> 01) von allen zwei aufeinander folgenden Zellen jedes Wortes testen. Dies kann gemacht werden durch zweimalige Ausführung des Algorithmus von Tabelle I, das erste Mal führen wir den Algorithmus aus, indem wir die Ein-Bit-Daten 0 und 1 durch 0000...00... und 1111...11... ersetzen, dann verwenden wir eine Übergangs-Sequenz bei der wir die Daten 0101...01... in alle RAM-Wörter schreiben, und wir führen die Sequenzen S1, S2, S3 und S4 unter Verwendung der Daten 0101...01... und 1010...10.... aus. Wurde der RAM unter Verwendung eines 1-aus-4-Multiplexen implementiert, so implementiert jede RAM-Zeile vier Wörter, wie in Fig. 1c gezeigt. Wir merken an, daß ein diesem Fall eine Zelle eines Wortes (d. h. Wort a) höchstens eine Nachbarzelle haben kann, die zu einem anderen Wort (d. h. Wort e) gehört. Somit müssen wir den RAM nur für zwei mögliche Übergänge (d. h. 0 --> 1, 1 --> 0) in jeder RAM- Zelle testen. Dies kann durch einmalige Ausführung des Algorithmus von Tabelle I gemacht S werden, unter Verwendung der Daten 0000...00... und 1111...11.... Dies gilt auch für ein Multiplexen höherer Ordnung (1-aus-8, 1-aus-16 usw.). In der Praxis sind RAMs im allgemeinen implementiert unter Verwendung eines Multiplexen von Spalten von 1-aus-4 oder von höherer Ordnung. Somit kann der Algorithmus von Tabelle I verwendet werden. Wir müssen nur das Schreiben einer 1 und das Schreiben einer 0 in eine Zelle austauschen gegen das Schreiben einer 1 und das Schreiben einer 0 in alle Wort-Zellen.
Betrachten wir jetzt den Algorithmus von Tabelle I. Unter Verwendung der Transformationsschritte 1 und 2 ist dieser Algorithmus, wie in Tabelle II gezeigt, modifiziert. In der Sequenz S1 dieser Tabelle bedeutet Rai, daß wie eine Lese-Operation auf Zelle i ausführen und der gelesene Wert gleich ai ist (der Anfangswert von Zelle i). In den anderen Sequenzen bedeutet Rai (bzw. R ), daß wir eine Lese-Operation ausführen und der erwartete Wert gleich a1 (bzw. ) ist. Wai und W bedeuten, daß wir ai oder in die Zelle i schreiben. Wir merken an, daß am Ende des Algorithmus der Inhalt des RAM's gleich seinem Anfangsinhalt ist. Somit ist der Algorithmus transparent. Tabelle II: Grundalgorithmus für den transparenten Test, abgeleitet von Marinescus Algorithmus.
Der Algorithmus von Tabelle II passt zu einem Bit-orientierten RAM. Wie wir gesehen haben, muß im Fall von Wort-orientierten RAMs, die ein Multiplexen von 1-aus-4 oder ein Multiplexen höherer Ordnung haben, der Algorithmus von Tabelle I unter Verwendung der Daten 0000...00... und 1111...11... anstatt der Bit-Daten 0 und 1 ausgeführt werden. Dies entspricht einem transparenten Algorithmus, der die in Tabelle II angegebenen Bit-orientierten Operationen auf allen Bits jedes Wortes ausführt. Somit, unter Verwendung der obigen Übereinkunft, können wir immer noch den Algorithmus von Tabelle II betrachten.
Für die Wort-orientierten RAMs, die ein 1-aus-2-Multiplexen von Spalten oder kein Spalten- Multiplexen verwenden, haben wir gesehen, daß der Standard- (d. h. nicht transparente) Algorithmus komplexer sein wird. Der entsprechende transparente Testalgorithmus kann aus diesen Algorithmen durch Anwendung der Transformationsschritte erhalten werden. Im folgenden betrachten wir den Fall von RAMs, die ein Multiplexen von 1-aus-4 oder höherer Ordnung haben, und somit können wir den Algorithmus von Tabelle II benutzen, wobei wir die oben erwähnte Übereinkunft machen.
Hinsichtlich der Signatur-Vorhersage wenden wir auf den Algorithmus von Tabelle II den Transformationsschritt 4 an, und wir erhalten den Algorithmus von Tabelle III. Die bei den Sequenzen dieses Algorithmus gelesenen Daten werden in den Ausgabeantwort-Kompaktierer geführt. Manchmal werden diese Daten invertiert um sie den Daten, die bei den Sequenzen von Tabelle II gelesen werden, anzupassen (d. h. die Daten, die während der ersten Lese-Operationen der Sequenzen S2º and S3º gelesen werden, und die Daten, die während der zweiten Lese- Operationen der Sequenz S4º gelesen werden, müssen invertiert werden, bevor sie in den Ausgabedaten-Kompaktierer geführt werden). Tabelle III: Signatur-Vorhersage-Sequenz.
Die Kompaktierungsanordnung wird bei den Sequenzen S1º, S2º, S3º und S4º aktiviert, um die Signatur vorherzusagen. Die vorhergesagte Signatur wird herausgeschoben oder sie wird in einem internen Register gespeichert. Dann werden die Sequenzen von Tabelle II ausgeführt. Die neue Signatur wird (extern oder intern) mit der vorhergesagten verglichen. Wir merken an, daß diese Antwortüberprüfung für jede Kompaktierungsanordnung gilt und nicht nur für die linearen, wie in dem von B. Koeneman vorgeschlagenen Verfahren.
Alternativ dazu können wir einen Signatur-Vorhersage-Algorithmus, gekoppelt mit einem Aufwärts- /Abwärts-Ausgabedaten-Kompaktierer, verwenden. Die Reihenfolge in diesem Algorithmus ist umgekehrt zu der im Signatur-Vorhersage-Algorithmus. Tabelle IV stellt den Signatur- Initialisierungs-Algorithmus vor, der Marinescus Testalgorithmus entspricht. Offensichtlich ist die Reihenfolge in diesem Algorithmus umgekehrt zu der des Algorithmus von Tabelle III. Tabelle IV: Signatur-Initialisierungs-Algorithmus
Im Fall des Signatur-Initialisierungs-Algorithmus wird die Ausgabeantwort-Kompaktierung durch ein Aufwärts-/Abwärts-Signaturregister durchgeführt (oder allgemeiner, durch einen Aufwärts- /Abwärts-Ausgabeantwort-Kompaktierer), der später beschrieben wird. Die Daten, die beim Signatur-Initialisierungs-Algorithmus gelesen werden, werden in den Aufwärts-/Abwärts- Ausgabeantwort-Kompaktierer geführt. Ähnlich zum Signatur-Vorhersage-Algorithmus werden einige der Daten des Signatur-Initialisierungs-Algorithmus invertiert, bevor sie in den Kompaktierer geführt werden. Die invertierten Daten sind die gleichen wie beim Signatur-Vorhersage- Algorithmus. Während dieser Phase ist der Kompaktierer im Abwärts-Modus (bzw. Aufwärts- Modus). Dann werden die Daten, die beim Grundalgorithmus für den transparenten Test gelesen werden (Tabelle II) in den Kompaktierer geführt. Während dieser Phase ist der Kompaktierer im Aufwärts-Modus (bzw. Abwärts-Modus). Entsprechend der grundlegenden Eigenschaft des Aufwärts-/Abwärts-Datenkompaktierers (siehe später) ist der Endzustand des Ausgabedaten- Kompaktierers gleich seinem Anfangszustand und daher ist er vorhersagbar.
Hinsichtlich der Fehlerüberdeckung haben wir gesehen, daß das Fehlermodell, das durch den Algorithmus von Tabelle I abgedeckt wird (d. h. einfache und mehrfache Haftfehler und idempotente Kopplungsfehler), die Symmetrieeigenschaft erfüllt. Somit ist die Fehlerüberdeckung nicht verringert.

Die Implementierung des transparenten BIST:

Im folgenden wird die Implementierung des transparenten BIST auf der Grundlage der Algorithmen der Tabellen III (Signatur-Vorhersage-Algorithmus) und II vorgestellt. Die Implementierung des transparenten BIST, die auf den Algorithmen der Tabellen IV (Signatur- Initialisierungs-Algorithmus) und II basiert, ist kaum anders und wird hier nicht ausführlich beschrieben. Jedoch ist die Entwurf des Aufwärts-/Abwärts-Datenkompaktierers innovativ und wird ausführlich beschrieben.
Um die BIST-Schaltungskomplexität zu vereinfachen, können wir eine hierarchische Herangehensweise verwenden, das heißt, wir betrachten die verschiedenen Hierarchieebenen des Algorithmus, und wir verwenden einen Block, um jede Hierarchieebene zu implementieren:
- Auf der höheren Ebene der Hierarchie haben wir die acht Sequenzen (S1º, S2º, S3º und S4º, S1, S2, S3 und S4) der Algorithmen der Tabellen II und III:
Ein 3-zelliger Binärzähler wird als Sequenz-Steuerblock verwendet. Die ersten vier Zustände des Zählers aktivieren die Sequenzen S1º, S2º, S3º und S4º von Tabelle III und die letzten vier Zustände aktivieren die Sequenzen S1, S2, S3 und S4 von Tabelle II. Die Signale S1', S2', S3' und S4', die in Fig. 2 durch die vier NOR-Gatter erzeugt werden, sind gleich: S1' = S1º + S1, S2' = S2º + S2, S3' = S3º + S3, S4' = S4º + S4 und das Signal Sº ist: Sº = S1º + S2º + S3º + S4º.
2 - Innerhalb jeder Sequenz müssen wir die Adressen der verschiedenen Zellen generieren. Zu dieser Hierarchieebene gehört der Adress-Generator:
Der Algorithmus von Tabelle I (und somit die der Tabellen II und III) erfordert, alle Zellen des RAM's zu adressieren. Die Reihenfolge der Adressierung ist nicht von Bedeutung (Der Algorithmus ist funktional und somit unabhängig von der topologischen Implementierung des RAM's). Wenn jedoch die RAM-Zellen bei den Sequenzen S1 und S2 in einer bestimmten Reihenfolge adressiert wurden, so müssen sie bei den Sequenzen S3 und S4 in der umgekehrten Reihenfolge adressiert werden. Diese Adressierung kann von einem Aufwärts-/Abwärts-Zähler durchgeführt werden, welcher in den meisten der bekannten BIST-Anordnungen verwendet wird. In dieser Untersuchung werden wir die Aufwärts-/Abwärts-LFSRs verwenden, die wir in (NICOLAIDIS, M. "An efficient Built-In Self-Test for functional test of embedded RAMs", In Proc. 15th International Symposium on Fault tolerant Computing, Ann Arbor, Juni 85, USA) eingeführt haben. Dieser Generator ist kompakter als die Aufwärts-/Abwärts-Zähler, wie im obigen Artikel behauptet wird. Jedoch tritt die wichtigere Verbesserung, die durch die Aufwärts-/Abwärts-LFSRs ermöglicht wird, in dem Fall ein, wenn der RAM ein eingebetteter Block ist. In jenem Fall kann das Aufwärts-/Abwärts-LFSR als Signaturregister für einen anderen Block verwendet werden, oder es kann mit einem Prüfpfad oder einem Boundary-Scan-Verfahren kombiniert werden, wie später erklärt wird.
Ein Aufwärts-/Abwärts-LFSR der Längen mit externem XOR kann wir folgt entworfen werden:
- bei der Aufwärts-Funktion ist die Schaltung wir ein normales LFSR der Längen mit externem XOR konfiguriert.
- bei der Abwärts-Funktion ist die Schieberichtung umgekehrt (Aufwärts-Funktion: Verschiebung nach rechts, Abwärts-Funktion: Verschiebung nach links). Die Rückkopplung der Abwärts- Funktion ist von der Rückkoppplung der Aufwärts-Funktion wie folgt abgeleitet:
a) wenn der Ausgang der Zelle Ck für die Rückkopplung der Aufwärts-Funktion verwendet wird, so wird der Ausgang der Zelle Cm (mit m = (k+1) mod n) für die Rückkopplung der Abwärts- Funktion verwendet,
b) der Ausgang der Rückkopplung der Abwärts-Funktion wird als ein Eingang der n-ten Zelle verwendet.
Ein Aufwärts-/Abwärts-LFSR der Länge 5 mit externem XOR ist in Fig. 3 angegeben. Dieses LFSR wurde von einem normalen LFSR (Aufwärts-Konfiguration) abgeleitet, das dem primitiven charakteristischen Polynom X&sup5; + X² + 1 entspricht.
Das Aufwärts-/Abwärts-LFSR der Längen mit internem XOR kann von einem normalen LFSR mit internem XOR wie folgt abgeleitet werden:
Wenn bei der Aufwärts-Funktion die Eingabe der Zelle Ck + 1 gleich An Ak ist, dann ist bei der Abwärts-Funktion die Eingabe von Ck gleich A1 Ak + 1 (wobei Ai die Ausgabe der Zelle Ci ist), anderenfalls ist die Eingabe von Ck gleich Ak + 1.
Abschließend, um alle 2n Binärvektoren zu erzeugen, muß man ein LFSR mit primitivem charakteristischen Polynom verwenden und in die Rückkopplungsschleife ein NOR-Gatter mit n-1 Eingängen einfügen (siehe Mc CLUSKEY E. J., "Logic design principles". Prentice Hall, Englewood Cliffs, New Jersey 07632, 1986). Die Aufwärts-/Abwärts-Implementierung, die dieser Schaltung entspricht, kann leicht abgeleitet werden, wie in Fig. 4 veranschaulicht wird (für ein LFSR mit externem XOR). Das LFSR wird mit dem alles-0-Zustand initialisiert. In Fig. 4 ziehen wir Vorteil aus der NOR-Funktion, um die Signale FUp und FDown zu erzeugen (Ende der Aufwärts- und der Abwärts-Sequenzen), welche für die BIST-Implementierung nützlich sind (siehe die Gleichungen für die Signale Lck und CSEQ, die später vorgestellt werden).
Der Entwurf für die interne XOR-Implementierung kann leicht auf ähnliche Weise abgeleitet werden und wird hier nicht ausführlich dargestellt.
3 - Wenn eine Zelle adressiert wird, haben wir verschiedene Lese- und Schreib-Operationen auszuführen. Ein Zeitpunkt-Generator wird verwendet, um den Zeitpunkt festzustellen, bei dem wir jede dieser Operationen ausführen:
Wir merken an, daß die Sequenzen von Tabelle III vier Operationen in jeder RAM-Zelle ausführen. Somit benötigen wir vier grundlegende Zeitpunkte, um diese Operationen auszuführen plus einen Zeitpunkt, um den Zustand der BIST-Schaltung zu ändern (nächste Adresse, nächste Sequenz usw.). Die benötigten Zeitpunkte T1, T2, T3, T4 und T5 können durch ein 5-stufiges Schieberegister erzeugt werden, das mit dem Zeitpunkt T1 (Zustand 10000) initialisiert wird. Wie wir gesehen haben, unterscheiden sich die Sequenzen S1º, S2º, S3º und S4º von S1, S2, S3 und S4 nur durch die Tatsache, daß es in ersteren keine Schreib-Operationen gibt. Somit, wenn der Zeitpunkt-Generator bei den Sequenzen S1º, S2º, S3º und S4º die Zeitpunkte blockiert, die den Schreib-Operationen der Sequenzen S1, S2, S3 und S4 entsprechen, so können wir diese beiden Mengen von Sequenzen durch die Verwendung einer Schaltung implementieren, die die Sequenzen S1, S2, S3 und S4 generiert.
Ein Zeitpunkt-Generator, der das zu tun gestattet, ist wie in Fig. 5 implementiert. Das Signal S1º + S3º = (S1' + S3')Sº wird verwendet, um die Aktivierung der Zeitpunkte T2, T3 und T4 bei den Sequenzen S1º und S3º zu verhindern, und das Signal S2º + S4º = (S2' + S4') Sº wird verwendet, um die Aktivierung der Zeitpunkte T2 und T4 bei den Sequenzen S2º und S4º zu verhindern (während dieser Zeitpunkte führen wir Schreib-Operationen in den Sequenzen S1, S3 bzw. S2, S4 aus).
4 - Ein Testdaten-Generator ist notwendig, um die Daten zu erzeugen, die in den RAM geschrieben werden sollen. Da jedes Datum, das in den RAM geschrieben werden soll, gleich dem letzten vom RAM gelesenen Datum ist oder gleich seinem Inversen, wird ein Register (Testdaten- Register genannt) verwendet, um diese Daten zu speichern, wie in Fig. 6 gezeigt wird. In dieser Figur wird das Signal W/R verwendet, um die gelesenen Daten zu speichern oder um den Daten-Bus mit dem direkten oder inversen Inhalt des Registers zu laden (d. h. den Daten, die in den RAM geschrieben werden sollen). Das Signal VT wählt den direkten oder den inversen Inhalt des Registers, entsprechend den Anforderungen des Algorithmus.
5 - Zuletzt verwendet ein kombinatorischer Block die Signale, die von den anderen Blöcken erzeugt wurden und gereriert das Signal, welches den Typ der Operation bestimmt (Lesen oder Schreiben), die Daten, die zu schreiben sind usw. Dies ist der Operations-Steuerblock. Die generierten Signale sind:
- W/R = (S1' + S3')(T2 + T3 + T4) + (S2 + S4')(T2 + T4). Dieses Signal legt während der Testphase den Wert des Lese-/Schreib-Steuereingangs des RAM's fest. Es wird auch in Fig. 6 verwendet. Aus Gründen, die zuvor erklärt wurden, nimmt dieses Signal die gleichen Werte sowohl bei den Sequenzen von Tabelle II als auch bei den von Tabelle III an.
- VT = (S1' + S2')T4 + (S1 + S4').T2 + S3' T3. Dieses Signal nimmt ebenfalls die gleichen Werte sowohl bei den Sequenzen von Tabelle II als auch bei den von Tabelle III an.
- LCk = T5 + S2.Fup. Dieses Signal ist der Takt des Adress-Generators.
- CSEQ = T5 +[( /Down). Fup + ( /Down). Fdown]. Dieses Signal ist der Takt des Sequenz-Steuerblocks.
Die Gleichungen für die obigen Taktsignale gelten für Flip-Flops, welche ihren Zustand ändern, wenn das Taktsignal aktiv ist. Für alle anderen Flip-Flop-Typen müssen diese Gleichungen modifiziert werden.
- R = (S2º + S3º)T1 + S4ºT3). Dieses Signal wird verwendet, um die Daten, die bei Zeitpunkt T1 der Sequenzen S2º und S3º und bei Zeitpunkt T3 von Sequenz S4º gelesen wurden, zu invertieren, bevor diese in den Ausgabe-Kompaktierer geführt werden. Dies gestattet, die gleichen erwarteten Signaturen für die Sequenzen von Tabelle II und III zu haben.
6 - Die Überprüfung der Ausgabeantwort wird durch einen Ausgabe-Kompaktierungsblock durchgeführt. Dieser Block kann ein MISR sein (Multiple Input Signature Register) oder jede andere Kompaktierungsanordnung. Die Signatur, die während der Sequenzen von Tabelle II berechnet wurde, wird mit der Signatur verglichen, die während der Sequenzen von Tabelle III berechnet wurde. Der Vergleich kann intern im Chip oder extern (die Signaturen werden herausgeschoben) gemacht werden. Wie zuvor gesagt wurde, erlaubt das Signal R die Invertierung einiger Daten, die in den Ausgabe-Kompaktierer geführt werden. Das Signaturregister (oder allgemeiner der Ausgabedaten-Kompaktierer), der bei dieser Anordnung verwendet wird, ist ein Standard-Baustein und muß nicht vorgestellt werden. Die Anordnung betreffend, die auf dem Signatur-Initialisierungs-Algorithmus basiert (Tabelle IV), benutzt er einen innovativen Datenkompaktierer, der unten beschrieben wird:
Im Fall dieser Anordnung werden wir einen Aufwärts-/Abwärts-Ausgabedaten-Kompaktierer verwenden, um eine vorhersagbare Signatur zu erhalten. Während des Abwärts- (bzw. des Aufwärts-) Modus kompaktieren wir die Daten, die im Algorithmus von Tabelle IV gelesen wurden, und während des Aufwärts- (bzw. des Abwärts-) Modus kompaktieren wir die Daten, die im Algorithmus von Tabelle II gelesen wurden (einige dieser Daten müssen, wie oben erklärt, invertiert werden). Da die Datenfolgen, die während dieser Modi in den Datenkompaktierer geführt werden, die gleichen sind, aber die umgekehrte Reihenfolge besitzen, ist die Endsignatur gleich dem Anfangszustand des Datenkompaktierers, und ist somit vorhersagbar. Dieses Verhalten kommt von der Tatsache, daß wir einen Aufwärts-/Abwärts-Datenkompaktierer so definieren, daß er die folgende Eigenschaft hat: wenn die Zustandsübergangsfunktion des Aufwärts-Modus (Dateneingabe = Dq, gegenwärtiger Zustand = Sq) → nächster Zustand = Sq+1 ist, dann haben wir im Abwärts-Modus (Dateneingabe = Dq, gegenwärtiger Zustand = Sq+1) -* nächster Zustand = Sq. Wenn wir zum Beispiel wünschen, ein Aufwärts-/Abwärts-Signaturregister zu verwenden, welcher sich im Aufwärts-Modus wir ein MISR verhält, dann wird das Aufwärts-/Abwärts- Signaturregister implementiert unter Verwendung eines Aufwärts-/Abwärts-LFSR's, wie das zuvor beschriebene. Im Aufwärts-Modus arbeitet das Signaturregister wie ein herkömmliches MISR.
Während des Abwärts-Modus werden die Eingaben der Zellen wie folgt berechnet:
Wenn beim Aufwärts-Modus die Eingabe einer Zelle i dj li ist (wobei dj das Bit j des Eingabedatums ist und li das Signal, das in die Zelle i des Aufwärts-/Abwärts-LFSR's bei dessen Aufwärts-Modus geführt wird), dann ist beim Abwärts-Modus des Signaturregisters die Eingabe der Zelle i-1 dj li-1' (wobei li-1' das Signal ist, das in die Zelle i-1 des Aufwärts-/Abwärts-LFSR's bei dessen Abwärts-Modus geführt wird). Im obigen wird im Fall i = 1 (erste Zelle des LFSR's) i-1 durch n (letzte Zelle des LFSR's) ersetzt. Diese Konstruktion ist in Fig. 7 illustriert, wobei ein LFSR mit externem XOR verwendet wird. Diese Konstruktion gilt sowohl für serielle Signaturregister (in diesem Fall haben wir nur ein Eingabedatum) als auch für parallele Signaturregister (MISR).
Bemerkt sein, daß der transparente Testalgorithmus, der in diesem Abschnitt implementiert wird, von dem von Marinescus abgeleitet wurde, welcher zwei Testdatenvektoren erfordert, der nur aus Nullen bestehende und der nur aus Einsen bestehende. In jenem Fall erfordert die transparente BIST-Implementierung die Verwendung des Signals VT. Wenn VT = 1, so erhält man die Testdaten durch invertieren aller Bits des Testdatenregisterinhalts, während, wenn VT = 0, die Testdaten gleich dem Inhalt des Testdatenregisters sind (siehe Fig. 6). Wenn der RAM-Testalgorithmus irgendwelche zwei anderen Testvektoren verwendet, benötigen wir wieder ein Signal VT, aber in diesem Fall sind die Bitpositionen, die zu invertieren sind, verändert. Zum Beispiel, wenn der Standard-Testalgorithmus die Testdaten 010101...01 und 101010...10 verwendet, so wird VT = 1 die ungeraden Bitpositionen invertieren und VT = 0 wird die geraden Bitpositionen invertieren. Wenn der Standard-Testalgorithmus drei oder vier Testvektoren verwendet, so müssen wir zwei Signale VT1 und VT2 verwenden. Zum Beispiel, wenn der Testalgorithmus die Testvektoren 000000...00, 111111...11, 010101...01 und 101010...10 verwendet, dann wird VT1 = 1 die ungeraden Bitpositionen invertieren und VT2 = 1 wird die geraden Bitpositionen invertieren, während VT1 = 0 und VT2 = 0 keine Bitposition invertieren werden. Somit werden wir für den Testvektor 000000...00 die Werte VT1 = 0 und VT2 = 0 verwenden, für den Testvektor 111111...11 werden wir die Werte VT1 = 1 und VT2 = 1 verwenden, für den Testvektor 010101...01 werden wir die Werte VT1 = 1 und VT2 = 0 verwenden, und für den Testvektor 101010...10 werden wir die Werte VT1 = 0 und VT2 = 1 verwenden.
Allgemeiner, wenn der Testalgorithmus m Testvektoren mit 2k-1 < m ≤ 2k verwendet, dann werden wir k Signale VT1, VT2,..., VTk verwenden. Im Extremfall benötigen wir r Signale VTi (wobei r die Länge der RAM-Wörter ist). Das heißt, wir werden ein Signal VT1 für jede Datenbitposition i verwenden.
Eine ähnliche Situation gilt für das Signal R, welches für des Invertieren einiger Bits verwendet wird, die in das Signaturregister geführt werden. Für eine Zahl m (m> 2) von Testvektoren, wird das Signal R in mehrere Signale R1 aufgespalten. Für 2k-1 < m ≤ 2k verwenden wir k Signale Ri. Im Extremfall werden wir ein Signal R1 für jede Datenbitposition i verwenden.

Prüfpfad-basiertes transparentes RAM-Testen:

Das transparente RAM-Testen kann auch unter Verwendung von Prüfpfad-Verfahren implementiert werden. Solch eine Implementierung ist besser geeignet, wenn wir in einer Schaltung das transparente Testen sowohl von RAM-Blöcken als auch von kombinatorischen Blöcken implementieren, da das transparente Testen von Logikblöcken Prüfpfad-Verfahren verwendet.
Das Prüfpfad-basierte transparente RAM-Testen ist unten illustriert.
Für Standard-Testalgorithmen kann der Prüfpfad benutzt werden, um die Adressvektoren zu den Adress-Eingabeleitungen zu bringen und/oder die Testdaten an die Daten-Eingabeleitungen zu bringen und/oder die Ausgabeantworten einzusammeln.

Für transparente Testalgorithmen:

a) Die Adressierung ist die gleiche wie für Standardalgorithmen. Daher sind keine speziellen Verfahren notwendig, um die Adressvektoren anzuwenden.
b) Die Testdaten sind festgelegt durch den Inhalt des Testdatenregisters, welches die Daten der letzten Lese-Operation speichert. Wenn eine Schreib-Operation ausgeführt wird müssen einige Bits des Testdatenregisters invertiert werden. In der BIST-Implementierung war dies durch die Werte der Signale VTi festgelegt. Im Extremfall weisen wir jeder Bitposition i des Testdatenregisters ein Signal VTi zu. Das Verfahren, das für die Prüfpfad-Implementierung verwendet wird, ist ähnlich. Jeder Bitposition des Testdatenregisters wird ein Signal VTi zugewiesen. Dann wird der Prüfpfad verwendet, um die Werte des Signals VTi zu transportieren.
c) Einige Daten, die während der Signatur-Vorhersage Sequenz gelesen wurden, müssen invertiert werden, bevor sie in das Signaturregister geführt werden. In der BIST-Implementierung wurden die Bitpositionen, die zu invertieren sind, durch die Werte der Signale Ri bestimmt. Das Verfahren, das für die Prüfpfad-Implementierung verwendet wir, ist ähnlich. Ein Signal Ri wird jeder Bitposition i der RAM-Datenausgänge zugewiesen. Die Werte Ri werden durch den Prüfpfad hereingebracht (der gleiche, der verwendet wird, um die Werte VTi zu transportieren). Die Signale Ri werden wie folgt verwendet: wenn ein Datum vom RAM gelesen wurde, wird es in das Testdatenregister gespeichert. Dann wird der Inhalt des Testdatenregisters auf den Daten-Bus geladen, nachdem einige Bits dieser Inhalte entsprechend der Werte der Signale Ri invertiert wurden. Dann wird der Daten-Bus verbunden mit dem Signaturregister oder mit dem Prüfpfad, der die Ausgabeantworten einsammelt.
Der Mechanismus, der in Fig. 8 dargestellt wird, erlaubt es, beide in b) und c) beschriebenen Operationen auszuführen. Bemerkt sei, daß, um diese Operationen effizient auszuführen, wir die Testdaten modifizieren können, wie später gezeigt wird. Zum Beispiel, anstatt die Testvektoren 000000...00 und 111111...11 zu verwenden, kann man die Testvektoren 010101...01 und 101010...10 verwenden. Dies entspricht den Vektoren 010101...01 und 101010...10 für die Signale VTi und Ri. Diese Vektoren können einer vom anderen durch nur eine Verschiebung erhalten werden..

Verbesserte transparente BIST- und Prüfpfad-Implementierungen:

Im folgenden zeigen wir, daß die Verwendung eines Aufwärts-/Abwärts-LFSR's statt eines Aufwärts-/Abwärts-Zählers als Adressgenerator erlaubt, die transparenten BIST- und Prüfpfad- Implementierungen für eingebettete RAMs zu verbessern. In vielen ASICs sind RAMs eingebettete Blöcke. Zum Beispiel können die Adressen der RAMs durch einen anderen Block, wie in Fig. 9 gezeigt, erzeugt werden. In einer globalen BIST-Implementierung der integrierten Schaltung muß der Block 1 ebenfalls geBISTed werden. Beispielsweise können ein Testmustergenerator und ein Signaturregister für diesen Block verwendet werden.
Die transparenten RAM-BIST-Implementierungen oder jede andere RAM-BIST-Implementierung, welche ein Aufwärts-/Abwärts-LFSR als Adressgenerator verwenden, gestatten eine sehr ökonomische Lösung für dieses Problem: das Aufwärts-/Abwärts-LFSR kann einfach zu einem MISR rekonfiguriert werden, um die Signaturanalyse für den Block 1 durchzuführen. Auf der anderen Seite haben die Aufwärts-/Abwärts-Zähler, die in anderen BIST-Anordnungen verwendet werden, nicht diesen Vorteil.
Ein verbreitetes Verfahren des testfreundlichen Entwurfs verwendet den Prüfpfad, um Zugang zu den Eingängen und Ausgängen von eingebetteten Blöcken zu erlangen. Ein Nachteil dieses Verfahrens ist es im allgemeinen, daß, wenn ein Block k Eingänge hat, so benötigt man k Takte (k Verschiebungen), um jeden Testvektor anzuwenden. Die Verwendung eines Aufwärts-/Abwärts- LFSR's gestattet dieses Problem zu lösen. Eine effiziente BIST-Implementierung für ASICs verwendet den Prüfpfad, wie in Fig. 11 gezeigt. In dieser Figur erlaubt ein einfacher Pseudozufalls-Testmustergenerator alle Blöcke über den Prüfpfad zu testen. Im allgemeinen sichert der Pseudozufallstest eine gute Fehlerüberdeckung für die kombinatorischen Blöcke und ebenso für die sequentiellen, welche (über den Prüfpfad) wie kombinatorische getestet werden. Auf der anderen Seite kann ein deterministische BIST oder ein transparenter BIST für RAMs effizient implementiert werden und sichert eine viel höhere Fehlerüberdeckung als der Pseudozufalls-BIST. In solch einer Anordnung ist es wichtig, einen Adressgenerator zu haben, der mit dem Prüfpfad kompatibel ist, um die Testzeit zu reduzieren. Wir merken an, daß, wenn wir in den Eingang des Prüfpfades den Ausgang einer Zelle eines n-Bit-LFSR's führen, so können wir nachweisen, daß wir n Verschiebungen für den ersten Vektor benötigen und eine Verschiebung für jeden anderen Vektor. Wenn also jemand ein Aufwärts-/Abwärts-LFSR verwendet, dann muß er bei der Aufwärts-Operation den Ausgang einer Zelle (zum Beispiel der n-te Zelle) zum Eingang des Prüfpfades führen. Ein spezielle Implementierung des RAM-Prüfpfad-Teils erlaubt, diese Eigenschaft für die gesamte (d. h. Aufwärts- und Abwärts-) Operation des LFSR's zu garantieren. Der kritische Punkt ist der Übergang von der Aufwärts- zur Abwärts-Funktion und umgekehrt. Wir erläutern die Implementierung für die LFSR's mit externem XOR:
- Der Prüfpfad-Teil, der mit den RAM-Adresseingängen korrespondiert, ist implementiert, um sowohl Linksverschiebe- als auch Rechtsverschiebe-Operationen auszuführen, wie in Fig. 10 gezeigt wird.
- bei der Aufwärts-Funktion des LFSR's führen wir den Eingang der Zelle 1 des LFSR's in den Prüfpfad, während wir bei der Abwärts-Funktion des LFSR's den Eingang der Zelle n des LFSR's hineinführen.
Diese einfachen Modifikationen erlauben es uns (bei der Abwärts-Operation) die inverse Sequenz auf die RAM-Adresseingänge anzuwenden, wobei eine Verschiebung pro Adressvektor verwendet wird. Diese Tatsache ist leicht nachzuprüfen und wird hier nicht ausführlich dargestellt. Bemerkt sei, daß, wenn man von einer aufwärtigen Adressierungssequenz zu einer abwärtigen übergeht (z. B. wenn man von Sequenz S2 zur Sequenz S3 im Algorithmus von Tabelle I übergeht), dann muß die Aufwärts-Funktion des RAM-Adresseingangs-Prüfpfadteils aktiviert werden (d. h. SUp/Down = 1) wenn alle Aufwärts-Adressen an die RAM-Adresseingänge geführt worden sind. Das heißt, SUp/Down wird 1 mit einer Verzögerung von m Takten nach der Aktivierung der Abwärts-Funktion (d. h. Lup/Down = 1) des Aufwärts-/Abwärts-LFSR's (wobei m die Prüfpfad- Länge zwischen dem Aufwärts-/Abwärts-LFSR und dem RAM-Adresseingangs-Prüfpfadteil ist).
Ein ähnliches Verfahren wird verwendet, wenn man von einer abwärtigen Adressierungsfolge zu einer aufwärtigen übergeht.
Die obige Anordnung kann auf jeden RAM-Block des Systems angewendet werden.
Für alle geBISTeten RAMs kann ein einziger Steuerblock verwendet werden, da dieser Block unabhängig von der Größe des RAM's ist. Es wird nur ein LFSR sowohl für die Testmustergenerierung von kombinatorischen (oder sequentiellen) Blöcken als auch die RAM- Adressgenerierung verwendet. Während des Tests eines RAM-Blocks wird der Testmustergenerator rekonfiguriert, um ein Aufwärts-/Abwärts-LFSR der entsprechenden Länge zu ergeben. Der Prüfpfadteil, der den RAM-Adresseingängen entspricht, wird ebenso rekonfiguriert, wie in Fig. 10 gezeigt wird. Der Datengenerator ist ein sehr kompakter Block (siehe Fig. 4), so daß er nahe an jedem RAM-Block ohne bedeutenden zusätzlichen Flächenverbrauch implementiert werden kann. Die globale BIST-Anordnung ist in Fig. 11 angegeben.
Wenn die Ausgabeantwort-Prüfung durch einen Vergleicher nahe der RAM-Ausgänge durchgeführt wird, dann müssen die Ausgabedaten des RAM's nicht in den Prüfpfad geführt werden, der in Fig. 11 verwendet wird.
Abschließend sei bemerkt, daß für eine Prüfpfad-Implementierung, bei der der Testmustergenerator nicht auf dem Chip implementiert ist, man die hier vorgeschlagene BIST- Implementierung simulieren kann. Aufgrund der oben vorgestellten Eigenschaften können die resultierenden Testadresssequenzen in die Schaltung mittels eines Zyklus mit einem Testvektor pro Takt hineingeschoben werden. Natürlich muß der Teil des Prüfpfads, der den Adresseingängen des RAM's entspricht, so implementiert werden, daß eine Linksverschiebung und eine Rechtsverschiebung möglich ist (wie in Fig. 10). Diese Vorteile gehen verloren, wenn man eine Adressreihenfolge verwendet, die auf dem binären Zählen beruht.
Hinsichtlich der Testdaten bemerken wir, daß der Datengenerator ein kompakter Block ist, so daß er nahe jedes RAM-Blocks ohne bedeutenden zusätzlichen Flächenverbrauch implementiert werden kann. Wenn im Fall des Standard- (d. h. nicht-transparenten) Testalgorithmus jemand entscheidet, die Testdaten über einen Prüfpfad anzuwenden, so benötigt er, wenn er als Testdaten die Vektoren 00000...00 und 11111...11 verwendet (wie im Fall von Marinescus Algorithmus, angewendet auf RAMs, die ein Spalten-Multiplexen von 1-aus-4 oder größerer Ordnung haben), n Verschiebungen, um jeden dieser Vektoren anzuwenden. Dieses Problem kann vermieden werden durch die Verwendung der Vektoren 01010...01 und 10101...10, weil der eine aus dem anderen durch eine Verschiebung hervorgeht. Mit Folgerung 1 hat der resultierende Algorithmus die gleiche Fehlerüberdeckung wie der originale. Dies ist deshalb so, weil die neuen Testvektoren von den ursprünglichen durch Invertierung der Werte des zweiten, vierten, sechsten usw. Bits abstammen. Dies kann erweitert werden für den Fall, daß der Algorithmus mehrere Datenpaare verwendet. Wenn der Algorithmus zum Beispiel die Datenpaare (000000...000, 111111...11) und (101010...10, 010101...01) verwendet, (wie im Fall von Marinescus Algorithmus, angewendet auf RAMs, die ein 1-aus-2-Multiplexen von Spalten haben), dann können diese Paare durch die Paare (001100...11, 110011...00) und (100110...01, 011001...10) ersetzt werden. In diesem Fall benötigen wir zwei Schiebe-Operationen, um einen Vektor eines Paares in den zweiten zu transformieren. Ähnlich, wenn die anfänglichen Paare (000000...000, 111111...111), (001001...001, 110110...110), (010010...010, 101101...101) und (011011...011, 100100...100) sind, so werden die neuen Paare (000111...000, 111000...111), (001110...001, 110001...110), (010101...010, 101010...101) und (011110...011, 110011...110) sein (in diesem Fall benötigen wir drei Schiebe-Operationen, um einen Vektor eines Paares in den zweiten zu transformieren), und so weiter. Somit reduzieren wir die Anzahl von Verschiebungen pro Datenvektor, welche gleich der Länge der RAM-Wörter sein würde, wenn diese Transformationen nicht verwendet werden. Wenn das Fehlermodell die Symmetrieeigenschaft erfüllt, dann garantiert Folgerung 1, daß diese Transformationen die Fehlerüberdeckung nicht verringern. Diese Transformationen sind auch nützlich für das transparente Testen, welches unter Verwendung eines Prüfpfads implementiert wurde. In diesem Fall reduzieren wir die Anzahl von Verschiebungen, die erforderlich sind, die Werte VTi und Ri in der Anordnung von Fig. 8 zu transportieren, da die Werte dieser Signale den Werten der Testvektoren des Standard-Testalgorithmus entsprechen.

Transparenter BIST für selbstprüfende RAMs:

Einige RAMs verwenden Selbstprüf-Mechanismen für eine nebenläufige online-Fehlererkennung. Zum Beispiel kann der RAM-Inhalt durch die Verwendung eines Paritäts-Codes geschützt werden, und die vom RAM gelesenen Daten werden durch einen oder mehrere Paritäts-Checker geprüft. In diesem Fall kann der oder die Paritäts-Checker auch verwendet werden, um die Ausgabeantwort- Prüfung durchzuführen. Dann besteht der transparente BIST in der Ausführung des Grundalgorithmus für den transparenten Test. Bei dieses Algorithmus erlauben die Code-Checker, die gelesenen Daten zu überprüfen. Die Signatur-Vorhersage-Sequenz wird umgangen und ebenso der Ausgabe-Kompaktierer.
Bemerkt sei, daß die Operationen, die während des Grundalgorithmus für den transparenten Test ausgeführt werden, den Code verändern können (z. B. die Invertierung eines Wortes, welches eine gerade Anzahl von Bits hat, transformiert eine ungerade Parität in eine gerade und eine gerade Parität in eine ungerade). Um die Inkonsistenz bei der Fehlererkennung zu vermeiden, wird die BIST-Schaltung ein Codewort-/Nicht-Codewort-Anzeigesignal erzeugen, entsprechend (NICOLAIDIS, M. "Self-exercising checkers for unified built-in self-test (UBIST)". IEEE Transactions on Computer-Aided Design, Vol. 8, Nr. 3, S. 1203-218, März 1989).

Transparenter BIST auf der Basis von Testsegmentierung:

Ein anderer Weg, den transparenten BIST zu implementieren, besteht darin, zu jedem Zeitpunkt ein RAM-Segment zu testen. Das Segment wird aus k Zeilen des RAM's bestehen. Ein kleiner Hilfs-RAM mit einer Größe, die gleich diesem Segment ist, wird in die BIST-Schaltung implementiert.
Vor dem Test jedes RAM-Segments wird der Segment-Inhalt in den Hilfs-RAM gespeichert. Dann wird das Segment unter Verwendung des Grundalgorithmus für den transparenten Test getestet. Bei dieses Algorithmus wird jedes gelesene Datum mit dem jeweiligen Datum des Hilfs-RAM's verglichen. Zu einigen Zeitpunkten muß eines der verglichenden Daten invertiert werden, damit der Vergleich passt (ähnlich der Invertierung einiger Daten während der Signatur-Vorhersage- Sequenz). Nach dem Ende des Tests des Segmentes wird der Inhalt eines anderen Segmentes in den Hilfs-RAM geladen, und das neue Segment wird getestet, und so weiter.
Dieses Verfahren erspart die Verwendung einer Signatur-Vorhersage-Sequenz und eines Ausgabe-Kompaktierers. Andererseits kann die Testsegmentierung die Fehlerüberdeckung reduzieren, und wir müssen einen Hilfs-RAM und einen Vergleicher verwenden. Darüberhinaus wird die Segmentierung komplexer und ebenso die BIST-Schaltung.
Die Fehlerüberdeckung kann verringert werden, weil wir nicht die Wechselwirkungen zwischen Zellen testen können, die nicht zum gleichen Segment gehören. Wenn jedoch der Abstand zwischen zwei Zeilen größer als eine Zahl d ist, kann man davon ausgehen, daß es keine Wechselwirkungen zwischen Zellen dieser Zeilen gibt. In diesem Fall können wir den RAM derart zerlegen, daß jede Menge von Zeilen, die einen gegenseitigen Abstand kleiner oder gleich d haben, zu mindestens einem Segment gehören. Zum Beispiel für d = 2 können wir Segmente, die mindestens 3 Zeilen haben, verwenden. Nehmen wir an, daß wir Segmente verwenden, die 4 Zeilen haben, dann wird das erste Segment aus den Zeilen 1, 2, 3 und 4 bestehen, das zweite Segment wird aus den Zeilen 3, 4, 5 und 6 bestehen, das dritte Segment wird aus den Zeilen 5, 6, 7 und 8 bestehen, und so weiter. Wir merken an, daß es eine Überlappung zwischen den Segmenten gibt, das heißt, einige Zellen des zweiten Segments gehören auch zum ersten Segment und einige andere Zellen dieses Segments gehören zum dritten Segment. Dies ist notwendig, um die Wechselwirkung zwischen den Randzellen dieser Segmente zu testen. Wir merken an, daß jedes Segment d + 1 Zeilen oder mehr enthalten muß. Die Auswahl basiert auf dem folgenden Kriterium: Die Erhöhung der Segmentgröße verringert die Testlänge, aber erhöht den zusätzlichen Hardwareverbrauch (Größe des Hilfs-RAM's).
Schließlich können wir d = 1 haben, und wir können Segmente aus zwei Zeilen verwenden. Die minimale Größe, die für den Hilfs-RAM erforderlich ist, wird gleich der Größe von zwei Zeilen des RAM's sein.
Eine alternative Implementierung des obigen Verfahrens ist wie folgt.
Für jedes RAM-Segment:
- lade den Segment-Inhalt in den Hilfs-RAM,
- teste das RAM-Segment mit einem Standard- (d. h. nichttransparenten) Testalgorithmus,
- stelle den Segment-Inhalt unter Verwendung des Inhalts des Hilfs-RAM's wieder her und gehe zum nächsten Segment.
Wir merken an, daß wir in diesem letzten Verfahren einen Standard-Testalgorithmus verwenden, um jedes Segment zu testen, aber am Ende der Testsitzung müssen wir den Segment-Inhalt wieder herstellen.

Claims

1. Eine Methode für das Testen eines Speichers, der mit einem Datenkompaktierer verbunden ist, und die folgenden Schritte umfaßt:

a) Ausführung einer transparenten Testfolge, die eine Abfolge von Lese- und Schreiboperationen für jede Speicherzelle beinhaltet, so daß der Initialzustand der Speicherzelle am Ende der Testfolge wiederhergestellt ist und wo die Ergebnisse einer vorbestimmten Anzahl von Leseoperationen dem Datenkompaktierer bereitgestellt werden;

b) Speicherung des Zustandes des Datenkompaktierers;

c) Ausführung einer Signatur-Vorhersagefolge; und

d) Vergleich des Zustandes des Datenkompaktierers mit dem gespeicherten Zustand, dadurch charakterisiert, daß die besagte transparente Testfolge die folgenden Schritte umfaßt:

- Bereitstellung einer nicht-transparenten Testfolge, die aufeinanderfolgende Lese-, Schreibe-1- und Schreibe-0-Operationen für jede Zelle beinhaltet;

- Wenn eine Gruppe aufeinanderfolgender Operationen mit einer Schreibe-Operation beginnt, dann wird eine Lese-Operation vor diese Schreibe-Operation eingefügt;

- Ersetzung jeder Schreibe-1- oder Schreibe-0-Operation durch eine Schreibe-Operation des ersten Wertes, der in der Zelle gelesen wurde; und

- Ersetzung jeder Schreibe-0- oder Schreibe-1-Operation durch eine Schreibe-Operation des Komplementes des ersten Wertes, der in der Zelle gelesen wurde, und dadurch daß die besagte Signatur-Vorhersagefolge die folgenden Schritte umfaßt:

- Ausführung von nur der vorbestimmten Anzahl von Lese-Operationen der transparenten Testfolge; und

- Bereitstellung des Ergebnisses jeder ausgeführten Lese-Operation für den Datenkompaktierer, entsprechend dem Ergebnis einer Lese-Operation, die dem Datenkompaktierer durch die besagte transparente Testfolge bereitgestellt wird, oder das Komplement hiervon, jedesmal wenn eine Schreibe-Operation, die der entsprechenden Lese-Operation in der besagten transparenten Testfolge vorausgeht, den Zustand der Zelle invertiert.

2. Eine Methode für das Testen eines Speichers, der mit einem Datenkompaktierer verbunden ist, wobei der besagte Datenkompaktierer einen ersten und zweite Analyse-Modus derart hat, daß, wenn er zweimal mit derselben Abfolge von Werten versorgt wird, einmal in der direkten Reihenfolge und einmal in der umgekehrten Reihenfolge, zwischen denen der Analyse-Modus hin und her geschaltet wird, der Initialzustand des Datenkompaktierers wiederhergestellt ist, und die folgende Schritte umfaßt:

a) Ausführung einer transparenten Testfolge, die eine Abfolge von Lese- und Schreiboperationen für jede Speicherzelle beinhaltet, so daß der Initialzustand der Speicherzelle am Ende der Testfolge wiederhergestellt ist und wo die Ergebnisse einer vorbestimmten Anzahl von Lese-Operationen dem Datenkompaktierer bereitgestellt werden;

b) Hin- und herschaltung des Analyse-Modus des Datenkompaktierers;

c) Ausführung einer Signatur-Initialisierungsfolge; und

d) Vergleich des Zustandes des Datenkompaktierers mit seinem Initialzustand, dadurch charakterisiert, daß die besagte transparente Testfolge die folgenden Schritte umfaßt:

- Ersetzung jeder Schreibe-0- oder Schreibe-1-Operation durch eine Schreibe-Operation des Komplementes des ersten Wertes, der in der Zelle gelesen wurde, und dadurch daß die besagte Signatur-Initialisierungsfolge die folgenden Schritte umfaßt:

- Ausführung von nur der vorbestimmten Anzahl von Lese-Operationen der transparenten Testfolge in umgekehrter Reihenfolge; und

3. Die Methode wie in Anspruch 2, dadurch charakterisiert, daß der Datenkompaktierer ein Aufwärts-/Abwärts- linear rückgekoppeltes Schieberegister (LFSR) mit kreisförmig verbundenen Flip-Flops umfaßt, und dabei die folgenden Schritte umfaßt:

- im ersten Analyse-Modus, Schaltung des LFSR's in den Aufwärts-Modus und Verbindung wenigstens eines zu kompaktierenden Signals mit dem Eingang eines entsprechenden Flip- Flops; und

- im zweiten Analyse-Modus, Schaltung des LFSR's in den Abwärts-Modus und Verbindung des besagten wenigstens einen Signals mit dem Eingang des dem besagten Flip-Flop zirkulär vorangehenden Flip-Flops.

4. Die Methode wie in Anspruch 1 oder 2, dadurch charakterisiert, daß Schritt a) mit Schritt c) vertauscht ist.

5. Die Methode wie in Anspruch 1 oder 2, dadurch charakterisiert, daß, wenn die letzte Schreibe-Operation der besagten transparenten Testfolge den Initialzustand der Zelle invertiert, sie den Schritt enthält, am Ende der Folge eine Lese-Operation einzufügen, gefolgt von einer Schreibe- Operation des Komplements des gelesenen Wertes.