You are on page 1of 135

POLITECNICO DI TORINO

Facoltà di Ingegneria
Corso di Laurea in Ingegneria Elettronica

Tesi di Laurea

Simulazione di Guasti per Circuiti Sequenziali Sincroni

Relatori: Prof. Ing. Paolo Prinetto Dott. Ing. Matteo Sonza Reorda Prof. Ing. Paolo Camurati

Candidati: Andrea Viarengo Claudio Quattrocchio Gianluca Siciliano

Febbraio 1993

Ringraziamenti
I candidati ringraziano vivamente il relatore Dott. Ing. Matteo Sonza Reorda per l’attenzione dedicata allo sviluppo di questo progetto di ricerca e per l’aiuto e i consigli relativi all’impostazione del lavoro e alla sua successiva realizzazione. Sono inoltre grati per la cordialità dimostrata nei due anni di collaborazione.

Indice
1 Nozioni di base 1 1.1 Introduzione.............................................................................................1 1.2 La simulazione dei circuiti digitali ..........................................................1 1.2.1 Verifica di progetto ...................................................................1 1.2.2 Il Collaudo.................................................................................2 1.2.3 La diagnosi ................................................................................2 1.3 Ritardo nella simulazione ........................................................................3 1.4 Modellizzazione dei circuiti ....................................................................4 1.5 Modellizzazione dei guasti ......................................................................6 1.6 Simulazione di macchina buona ..............................................................9 1.6.1 Circuiti Combinatori .................................................................9 1.6.2 Circuiti Sequenziali .................................................................10 1.7 Simulazione della macchina guasta .......................................................11 1.7.1 Circuiti combinatori ................................................................12 1.7.2 Circuiti Sequenziali .................................................................13 2 Tecniche di Simulazione 14 2.1 Introduzione...........................................................................................14 2.2 Organizzazione di un simulatore ...........................................................14 2.3 Descrizione analitica del circuito...........................................................16 2.4 Valutazione dei descrittori.....................................................................19 2.4.1 Tavola della verità...................................................................19 2.4.2 Operazioni logiche ..................................................................20 2.4.3 Considerazioni sul fanin..........................................................21 2.4.4 Valore forzante........................................................................22 2.4.5 Chiamate a procedure..............................................................24 2.5 Trattamento dei guasti ...........................................................................24 2.5.1 Iniezione dei guasti..................................................................24

I

indice

2.6 2.7

2.8

2.9

2.10 2.11 2.12 2.13

Iniezione fisica ....................................................................25 Mascheramento ...................................................................25 2.5.2 Fault list e Fault dropping .......................................................29 Con vettore..........................................................................30 Con lista concatenata ..........................................................30 2.5.3 Ripristino dello stato della macchina buona ...........................30 Duplicazione dello stato del circuito buono........................31 Iniezione del guasto opposto...............................................31 Memorizzazione dei nodi cambiati.....................................32 Metodo degli ID ..................................................................32 Simulazione seriale................................................................................33 Implementazione del simulatore............................................................33 2.7.1 Circuito interpretato ................................................................33 2.7.2 Circuito compilato...................................................................34 Tecniche di propagazione ......................................................................35 2.8.1 Algoritmo Oblivious ...............................................................35 2.8.2 Tecnica Event Driven..............................................................36 2.8.3 Confronto tra le due tecniche ..................................................39 Organizzazione dei vettori di ingresso e dei guasti ...............................40 2.9.1 Priorità di guasti ......................................................................41 2.9.2 Priorità di vettori d’ingresso....................................................41 Attività dei FF .....................................................................42 Simulazione Differenziale .....................................................................42 Simulazione Deduttiva ..........................................................................44 Simulazione Concorrente ......................................................................45 Simulazione Parallela ............................................................................48 2.13.1 Priorità di vettori di ingresso...................................................48 2.13.2 Priorità di guasti ......................................................................51

3 La Simulazione di Circuiti Guasti: Stato dell’arte 52 3.1 Introduzione...........................................................................................52 3.2 PROOFS ................................................................................................52 3.2.1 Logica del simulatore ..............................................................53 3.2.2 Simulazione macchina buona..................................................54 3.2.3 Simulazione macchina Guasta ................................................54 Eccitazione Guasti ..............................................................54 Raggruppamento dei guasti.................................................55

II

indice

3.3

3.4

3.5

3.6

Valutazione delle porte .......................................................55 Iniezione guasto ..................................................................56 Memorizzazione dello stato ................................................56 Ordine dei Guasti ................................................................58 3.2.4 Scheda riassuntiva di PROOFS...............................................59 PSF.........................................................................................................60 3.3.1 Divisione delle sequenze.........................................................60 3.3.2 Procedimento iterativo ............................................................61 3.3.3 Simulazione di macchina guasta .............................................62 3.3.4 Conclusioni .............................................................................62 3.3.5 Scheda riassuntiva di PSF .......................................................63 PARIS ....................................................................................................64 3.4.1 Logica del simulatore ..............................................................64 Parola di stato......................................................................64 Stato del circuito .................................................................64 3.4.2 Simulazione di macchina buona..............................................65 Approssimazione delle parole di stato ................................66 Strutturazione del circuito...................................................67 3.4.3 Simulazione macchina guasta .................................................68 Propagazione dei guasti ......................................................68 3.4.4 Limitazioni del simulatore PARIS ..........................................69 3.4.5 Scheda riassuntiva di PARIS...................................................70 HOPE.....................................................................................................71 3.5.1 Regioni libere da fanout ..........................................................71 3.5.2 Linea dominante ......................................................................71 3.5.3 Riduzione dinamica dei guasti ................................................72 3.5.4 Gruppi di equivalenza e pseudo guasti....................................73 3.5.5 Costruzione dei pacchetti di guasti..........................................73 3.5.6 Fase di simulazione e rivelazione............................................75 3.5.7 Scheda riassuntiva di HOPE ...................................................75 TORTLE_C ...........................................................................................76 3.6.1 Logica del Simulatore .............................................................76 3.6.2 La Simulazione........................................................................76 3.6.3 Estensione alla simulazione compilata....................................78 3.6.4 Simulazione Gerarchica ..........................................................78 3.6.5 Simulazione dei moduli...........................................................80

III

indice

3.6.6 3.6.7 3.6.8 3.6.9

Ottimizzazioni del codice compilato.......................................83 Implementazione e portabilità .................................................84 Limitazioni e possibili estensioni............................................86 Scheda riassuntiva di TORTLE_C ..........................................86 87

4 Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti 4.1 Introduzione...........................................................................................87 4.2 Simulatore sequenziale SEQSIM ..........................................................88 4.2.1 Algoritmo di simulazione........................................................88 4.2.2 Simulazione ED ......................................................................88 4.2.3 Struttura di propagazione ........................................................90 4.2.4 Valutazione dei descrittori ......................................................91 4.2.5 Iniezione dei guasti..................................................................91 4.2.6 Memorizzazione degli stati dei flip flop .................................91 4.2.7 Applicazione dei vettori di ingresso e dei flip flop .................92 4.2.8 Rivelazione guasti e fault dropping.........................................92 4.2.9 Risultati sperimentali ..............................................................93 4.3 Simulatore parallelo per circuiti sequenziali .........................................94 4.3.1 PARSEQv1 .............................................................................94 Simulazione di macchina guasta.........................................94 Iniezione dei guasti .............................................................95 Memorizzazione e applicazione dei flip flop......................97 4.3.2 PARSEQv2 .............................................................................99 Algoritmo di simulazione ...................................................99 Iniezione dei guasti ...........................................................100 4.3.3 Risultati sperimentali ............................................................101 4.4 Simulatore parallelo sequenziale compilato ........................................103 4.4.1 PARSECv1............................................................................103 4.4.2 PARSECv2............................................................................108 Procedure “ad hoc” ...........................................................108 Struttura di propagazione..................................................110 Schedulatore centrale ........................................................111 4.4.3 PARSECv3............................................................................112 Allocamento dinamico della memoria destinata ai flip flop..............................................................................112 Fault Dropping ..................................................................114 4.4.4 PARSECv4............................................................................116

IV

indice

4.4.5

Risultati sperimentali ............................................................119 Confronto tra la versione compilata e non compilata .......119 Tempi di compilazione .....................................................120 Confronto tra le versioni di PARSEC...............................121

5 Conclusioni 123 5.1 Lavoro svolto .......................................................................................123 5.2 Limiti di utilizzazione dei simulatori ..................................................124 5.3 Possibile lavoro futuro.........................................................................124 A I Circuiti di prova ISCAS-89 B Rapporti di potenza delle CPU Bibliografia 125 126 127

V

Capitolo 1 Nozioni di base
1.1 Introduzione

In questo capitolo introduttivo si intende riassumere quelli che sono i punti di partenza per lo studio della simulazione CAD dei circuiti logici VLSI, cioè le terminologie che verranno usate, i modelli utilizzati, le applicazioni alla realizzazione dei dispositivi elettronici

1.2

La simulazione dei circuiti digitali

La simulazione circuitale si rivela utile per la verifica di progetto e per il collaudo e la diagnosi.

1.2.1 Verifica di progetto
In questo caso la simulazione permette di predirre il risultato di uscita di un circuito logico permettendo di verificare se il circuito progettato rispetta le specifiche. Questo tipo di simulazione è comunemente noto come "Simulazione di macchina buona" (Good simulation).

1

Capitolo 1

Nozioni di base

1.2.2 Il Collaudo
Nella fabbricazione dei circuiti integrati è importante disporre di mezzi adeguati per il collaudo dei chip. Lo scopo ovviamente è quello di mettere sul commercio componenti privi di guasti (Faults); per guasto si intende un qualsiasi difetto di fabbricazione che altera il corretto funzionamento del circuito. La strategia più banale per il collaudo di circuiti logici combinatori è il cosiddetto collaudo esaustivo, consistente nell’applicazione di una sequenza di vettori di ingresso (Patterns) completa1. Per verificare il corretto funzionamento del circuito si confrontano quindi le uscite così ottenute con le uscite di un circuito campione (Golden circuit) oppure con vettori memorizzati in un dispositivo RAM, calcolati tramite la Good Simulation. Il collaudo esaustivo non è applicabile nel caso di circuiti combinatori con un elevato numero di ingressi o di circuiti sequenziali, perchè il numero dei vettori di ingresso da applicare diventa troppo elevato; per questo motivo sono state sviluppate tecniche atte a ridurre il numero di vettori da provare, così da generare una sequenza di collaudo (Test Pattern) di lunghezza minima che continua, tuttavia, a garantire una buona copertura (coverage) del circuito. Queste sequenze di collaudo vengono generate con opportuni programmi chiamati ATPG (Automatic Test Pattern Generator). Questi richiedono opportuni simulatori detti Simulatori di Macchina Guasta (Fault Simulator) i quali, dato un determinato pattern di ingresso, forniscono il numero di guasti che vengono rivelati da quel particolare pattern. Per simulare il circuito in esame vengono quindi iniettati tutti i possibili guasti che si possono verificare nel circuito, uno alla volta. I guasti sono prelevati da una lista dei Guasti (Fault List). Se, con il medesimo pattern, l'introduzione di un particolare guasto produce la medesima uscita prodotta dalla simulazione di macchina buona, quel guasto non viene rivelato (undetected fault); viceversa si dice che quel determinato pattern ha rivelato il guasto (detected fault).

1.2.3 La diagnosi
Permette l’individuazione di un guasto esistente nel circuito e dovremo pertanto sottoporre il circuito a tre passi fondamentali: collaudo, individuazione dei
1La sequenza di vettori di prova completa è costituita da 2n possibili combinazioni se n è il numero di ingressi primari

2

Capitolo 1

Nozioni di base

sintomi di mal funzionamento, ricerca del guasto presente nel circuito rispondente ai sintomi. Le tecnche di diagnosi comunemente adottate sono: • dizionario dei sintomi Elenco di comportamenti ingresso-uscita corrispondenti a determinate condizioni di malfunzionamento. Il dizionario permette di localizzare il guasto dall’analisi di uno o più sintomi elementari. • dizionario dei guasti È l'opposto del dizionario dei sintomi e permette di verificare la presenza di un determinato guasto applicando al circuito certi ingressi e verificando se le uscite sono quelle indicate.

1.3

Ritardo nella simulazione

Ogni porta introduce un ritardo nella propagazione del segnale che la attraversa; possiamo allora pensare di modellizzarla in modo da tenere separati il blocco logico da uno dedicato al solo ritardo temporale, come mostrato in Fig.1.1.

A u B

A AorB B Ritardo u

Fig.1.1: Rappresentazione del ritardo Il ritardo dipende da vari fattori, il più significativo dei quali è quello tecnologico relativo alla fase di costruzione; il costruttore fornisce tuttavia un range di valori, che permette di calcolare il ritardo complessivo del circuito che si intende studiare. La propagazione del ritardo di porta in porta è un problema rilevante per la simulazione: si possono infatti avere delle incertezze, seppure temporanee, sul

3

Capitolo 1

Nozioni di base

vettore di uscita. Nei circuiti sequenziali si è agevolmente superato l’inconveniente con una scelta accurata del periodo di temporizzazione esterna (clock), che è tale da essere maggiore del ritardo complessivo della rete. Dal punto di vista della simulazione possiamo avere: • Simulatori a ritardo zero: le porte sono considerate prive di ritardo. • Simulatori a ritardo 1: le porte hanno tutte un ritardo costante. • Simulatori a ritardo variabile: per ogni porta è specificato un ritardo minimo e un ritardo massimo.

1.4

Modellizzazione dei circuiti

Per poter simulare un circuito logico, è necessario darne una descrizione software tramite un modello matematico. Questo modello può essere più o meno accurato a seconda dell'esigenza. Distinguiamo varie modellizzazioni: • Modello a livello fisico Il circuito viene descritto in maniera molto accurata, considerando i componenti elettronici costituenti le porte logiche (giunzioni, FET, MOS). I segnali in gioco sono quindi di tipo analogico. • Modello a livello di porte Il circuito viene descritto a livello logico utilizzando i possibili tipi di operatori booleani. In questo caso occorre considerare segnali binari (0,1), ternari (0, 1, X), quaternari (0, 1, X, Z). • Modello comportamentale Il circuito viene descritto attraverso blocchi logici di cui è data una descrizione del funzionamento a prescindere da come il circuito è costituito internamente (contatori, multiplexer, shift register, ALU, CPU) Questa descrizione è fatta con opportuni linguaggi HDL (Hardware Description Languages). I circuiti logici che tratteremo sono quelli sequenziali che si possono vedere come estensione di quelli combinatori, a cui faremo talvolta riferimento.

4

Capitolo 1

Nozioni di base

Il circuito combinatorio risponde a determinate eccitazioni in ingresso con uscite che non dipendono dalla sequenza con cui sono applicati i vettori di ingresso.

i ng re ss i p r im a ri PI

circu i to co m b i n a to r io PO

u s cit e p r im a ri e

Fig. 1.2: Circuito combinatorio Nei sequenziali distinguiamo uscite primarie e pseudo-primarie: le prime sono le normali uscite della rete combinatoria; le seconde definiscono lo stato futuro del circuito combinatorio e saranno pertanto gli ingressi pseudo-primari applicati al successivo colpo di clock. Ne deriva che le uscite primarie dipendono non solo dagli ingressi primari ma anche dalla loro sequenza.
PI ingressi primari PO uscite primarie

circuito combinatorio PPO

ingressi pseudo-primari

PPI

uscite pseudo-primarie

CK

Fig. 1.3: Circuito sequenziale Definiamo inoltre i concetti di: • Stato presente: l’insieme dei valori delle uscite dei flip flop (PPI). • Stato futuro: l’insieme dei valori degli ingressi dei flip flop (PPO). • Stato interno: l’insieme dei valori di tutti i nodi esclusi i flip flop. • Stato totale: l’insieme dei valori di tutti i nodi del circuito (unione dello stato interno e dello stato presente).

5

Capitolo 1

Nozioni di base

1.5

Modellizzazione dei guasti

I guasti che si possono verificare nella progettazione e nell’analisi di un circuito elettronico sono molteplici e di varia natura, possono tuttavia essere catalogati in base a cinque attributi fondamentali secondo lo schema di Fig.1.4; non è facile pertanto costruire modelli che siano allo stesso tempo semplici e completi. Nella nostra trattazione verranno considerati solo i guasti relativi ai difetti di fabbricazione (failure); questi all'origine derivano dallo stesso processo di lavorazione del silicio in quanto talune piste potrebbero essere interrotte, fissando così quel punto del circuito ad un valore determinato (0,1) o indeterminato (intermittente, alta impedenza).

Caratteristiche dei guasti

Cause
Disturbi esterni Difetti dei componenti

Durata
Permanente Transitorio

Estensione
Locale Globale

Intermittente

Natura
Analogico Digitale

Valore
Determinato Indeterminato

Fig. 1.4 Il modello più semplice a cui sono riconducibili tutti gli altri è quello dello stuckat-0/1 che consiste nel fissare il valore di una particolare linea, su cui si è localizzato il guasto, a 0/1. È sperimentalmente dimostrabile con criteri di equivalenza, che la copertura con il modello stuck-at implica essenzialmente la copertura anche degli altri

6

Capitolo 1

Nozioni di base

Stuck-at-1

1

Stuck-at-0 0

Fig. 1.5: Modello stuck-at-0 e stuck-at-1 Tale modello sarà perciò da noi adottato per la simulazione; non dimenticando però che altri modelli sono possibili. A titolo di esempio citiamo lo stuck-short che rappresenta il possibile corto circuito tra due o più linee oppure lo stuckopen dove un collegamento rimane flottante. I guasti stuck at possono essere posizionati su linee in ingresso o uscita dalle porte e sono perciò detti stuck-input e stuck-output; sorge spontaneo chiedersi se esista una correlazione tra questi o se in certi casi siano la stessa cosa. Due o più guasti sono detti funzionalmente equivalenti se a parità di applicazione degli ingressi del circuito producono le stesse uscite. Un insieme di guasti tutti equivalenti tra loro costituiscono una classe di equivalenza. In Fig. 1.6 sono mostrati due esempi di equivalenza tra guasti stuck-input e stuck-output. Nel caso (a) f1 è equivalente al guasto multiplo (f2, f3), si noti però come f2, considerato singolarmente, non equivale nè f1 nè f3. Questo esempio mostra che il modello contenente stuck-output e stuck-input sia più completo del modello con solo stuck output. In (b) è evidenziato un caso in cui f2 e f1 danno origine allo stesso effetto (la linea l2 è posta ad 1 a causa di f1 o f2 indipendentemente dal segnale presente su l3). Sfruttando queste considerazioni si può effettuare un’operazione detta riduzione dei guasti (fault collapsing) avente lo scopo di eliminare i guasti equivalenti, scegliendo un solo rapprentante per ogni classe di equivalenza. Nell’ipotesi più semplificativa si possono utilizzare unicamente stuck-output.

7

Capitolo 1

Nozioni di base

S_a_0

f3 f2 S_a_0 S_a_0 l3 l1 S_a_0 f1 S_a_1

f1

l2

(a)

f2

(b)

Fig. 1.6: Equivalenza fra guasti stuck-input e stuck-output Un’ulteriore classificazione di come i guasti sono inseriti nel circuito determina due modelli usati per la simulazione: • Modello per guasti multipli: considera più linee guaste contemporaneamente. • Modello per guasti singoli: considera solo una linea guasta per volta. Il primo modello è più rispondente alla realtà in quanto l’introduzione dei guasti sul chip è un fenomeno puramente casuale e questi saranno distribuiti senza preferenze. Il secondo è un caso particolare del primo ed è molto più comodo e veloce da trattare. Esso trova la sua giustificazione nel fatto che un guasto eccita mediamente un numero limitato di elementi logici e, su circuiti mediamente grandi (qualche migliaio di porte), si può supporre che due o più guasti interessino insiemi disgiunti di porte, propagando perciò i loro effetti su uscite primarie diverse: basta quindi rivelare il guasto singolo per garantire la rivelazione di quello multiplo. Un problema che interviene trattando guasti multipli è quello del mascheramento, fenomeno nel quale due guasti sovrappongono i loro effetti in modo tale che il guasto totale non viene rivelato.

8

Capitolo 1

Nozioni di base

1.6

Simulazione di macchina buona

La simulazione di macchina buona di un circuito logico consiste nel determinare l’insieme dei vettori di uscita corrispondenti ad un determinato insieme di vettori di ingresso. Un programma di simulazione, in pratica, preleva le informazioni relative ai vettori di ingresso e alla descrizione circuitale da opportuni file e scrive i risultati su un altro file, come mostrato in Fig. 1.7. Nei paragrafi seguenti sono presentati i concetti base per effettuare la simulazione del circuito buono.

M o d e l lo C i rcu it a l e

Sim u la t o re

10110 01010 1 11 0 1

10110 01010 1 11 0 1

V e t t o ri d i u s cit a

V e t t o ri d i I n g re s s o

Fig. 1.7: Simulazione buona

1.6.1 Circuiti Combinatori
La strada più semplice per realizzare la simulazione di un circuito consiste nel raggruppare le porte per livello crescente e valutarle tutte indistintamente livello per livello a partire dai valori assegnati agli ingressi primari che sono per definizione a livello zero. Al passo di simulazione successivo, cioè quando viene applicato il nuovo vettore di ingresso, viene risimulato l’intero circuito; in Fig. 1.8 riportiamo un algoritmo per la simulazione di base relativa ai circuiti combinatori.

9

Capitolo 1

Nozioni di base

Per ogni vettore di ingresso { Applica il vettore ai nodi di ingresso Per ogni porta { Valuta la porta aggiorna il valore dei nodi del circuito } Stampa il vettore di uscita } Fig. 1.8: Algoritmo di simulazione dei circuiti combinatori

1.6.2 Circuiti Sequenziali
Premettiamo che volendo simulare il comportamento dei circuiti sequenziali è sempre possibile ricondursi al caso di circuiti combinatori se procediamo ad una preventiva assegnazione di tutti i flip flop a livello zero; dobbiamo cioè scomporre il circuito sequenziale assegnato in due blocchi fondamentali costituiti da una rete combinatoria e da un banco di flip flop (status register) a cui sono connessi gli ingressi pseudo-primari e le uscite pseudo-primarie, come avevamo illustrato in Fig.1.3. il segnale di clock non viene utilizzato, ma simulato trasferendo lo stato futuro presente sugli ingressi dei flip flop (PPO) sulle loro uscite (PPI). Quindi ogni passo di simulazione consiste nell’applicare sugli ingressi della rete combinatoria il vettore di ingresso in questione, e lo stato futuro generato al passo precedente. Facciamo notare che in generale non è possibile definire il comportamento di un circuito sequenziale se non ci riferiamo ad una sequenza specifica dei vettori di ingresso. Lo stato iniziale di un circuito è la configurazione del vettore PPI che viene associato al primo vettore, ed è arbitrario. Utilizzando una logica a tre valori, si può scegliere un valore incognito (vettore di "X"). Questa soluzione può generare sulle uscite primarie e pseudo-primarie valori indeterminati; in particolare queste ultime saranno applicate insieme al vettore successivo. Un’altra soluzione consiste nel porre lo stato iniziale al valore nullo (sicuramente coperto dalla più generale espressione formata da tutte X), resettando tutti i flip flop.

10

Capitolo 1

Nozioni di base

1.7

Simulazione della macchina guasta

In Fig. 1.9 è mostrato lo schema per la simulazione di macchina guasta: in questo caso, oltre ai file contenenti il modello circuitale e i vettori di ingresso della prova di collaudo da verificare, occorre fornirne un altro che contenga la modellizzazione dei guasti (fault list).

Modello Circuitale

10110 01010 11101

10110 01010 11101

Vettori di uscita Simulatore

Vettori di Ingresso

n. 12 n. 21 n. 33 Guasti non rivelati

n. 1 n. 2 n. 3

Lista dei Guasti

Fig. 1.9: Simulazione di macchina guasta È basilare introdurre i seguenti concetti: • Iniezione Estrazione del guasto da una lista e sua successiva introduzione su una linea del circuito; si vincola cioè il valore della linea al valore logico del guasto. • Eccitazione Dopo l'iniezione del guasto e l'applicazione del vettore di ingresso sui PI, parleremo di guasto eccitato se il valore logico assunto dalla macchina buona in corrispondenza dello stesso nodo di iniezione del guasto è di valore opposto a quello del guasto stesso.

11

Capitolo 1

Nozioni di base

• Propagazione Avviene solo se il guasto iniettato risulta eccitato: in tal caso è infatti necessario propagare il valore logico del nodo su cui è avvenuta l'iniezione del guasto rivalutando tutti i nodi che da esso discendono. Ovviamente non è detto che gli effetti del guasto si propaghino fino alle uscite primarie(PO). • Rivelazione Il guasto viene rivelato se si propaga fino alle uscite primarie, cioè il vettore di uscita differisce rispetto a quello calcolato nel caso di macchina buona. • Mascheramento Si parla di mascheramento per un guasto multiplo quando, pur essendo rivelabili i suoi guasti singoli componenti, questo non viene rivelato. In particolare presi due guasti di cui uno sia inserito nel cono di propagazione dell'altro, può verificarsi che il primo forzi un valore sul nodo in cui è presente il secondo, tale da non permettere l’eccitazione di quest’ultimo. • Copertura Viene definita come il rapporto tra il numero dei guasti rivelati da una prova di collaudo, e il numero totale dei guasti simulati; in pratica è una misura dell’efficienza del test considerato. Tuttavia anche un test con il 100% di copertura può non rappresentare una verifica esaustiva su tutti i possibili guasti fisici del circuito, in quanto viene considerato uno specifico modello di guasto.

1.7.1 Circuiti combinatori
Un possibile approccio alla simulazione dei circuiti combinatori in presenza di guasti è riportata in Fig. 1.10. L’idea è quella di comparare il vettore di uscita della macchina, ottenuta con l’introduzione di un guasto, con quello del circuito privo di errori in corrispondenza dello stesso vettore applicato in ingresso, al fine di ottenerne la rivelazione.

12

Capitolo 1

Nozioni di base

1.7.2 Circuiti Sequenziali
Per estendere quanto visto sulla simulazione di macchina guasta ai circuiti sequenziali, occorre tener presente che essendo questi dotati di memoria, gli effetti del guasto possono presentarsi agli ingressi pseudo-primari. Ogni passo di simulazione sarà quindi soggetto a due sorgenti di guasto: una localizzata in corrispondenza del sito originario, l’altra derivante dalla applicazione dello stato ereditato dal passo precedente, come mostrato nello schema di Fig. 1.11. In altri termini, l’iniezione di un guasto singolo fi in un circuito sincrono può essere vista come l'iniezione di un guasto multiplo nella sua rete combinatoria; tale guasto avrà come componenti fi e una serie di guasti localizzati sulle uscite del registro di stato.

Simulazione del guasto fi: Per ogni vettore di ingresso xi { Calcola le uscite y0 del circuito C0 (privo di guasti) Calcola le uscite yi del circuito Ci (circuito con la presenza di fi) Se l’uscita yi di Ci differisce dall’uscita y0 di C0 allora il guasto fi è rivelato dal vettore di ingresso xi } } Fig. 1.10: Algoritmo base per la simulazione di macchina guasta

x1 fi
Reset

x2 fi

x3 fi

Passo 1

Passo 2

Passo 3

Fig. 1.11: Propagazione dei Guasti nei circuiti sequenziali

13

Capitolo 2 Tecniche di Simulazione
2.1 Introduzione

Il problema del collaudo dei circuiti VLSI diventa sempre più importante a causa dell’aumento della scala di integrazione, così da avere molte porte logiche in spazi molto ristretti. Questo comporta infatti un aumento della probabilità di avere guasti in fase di fabbricazione. Inoltre il numero elevato di componenti logici che vengono integrati in un unico chip rende la simulazione onerosa in termini di tempo di elaborazione e dispendio di memoria. Sono quindi necessarie tecniche particolari per aumentare l’efficienza e la velocità della simulazione. In questo capitolo ci occuperemo degli algoritmi più noti, ma prima è opportuno definire una possibile struttura dati atta a descrivere analiticamente i circuiti logici, a cui faremo riferimento negli algoritmi, per averne una più chiara comprensione; ciò comunque non impedisce di applicare le tecniche che saranno viste con strutture differenti.

2.2

Organizzazione di un simulatore

Abbiamo fino ad ora parlato di simulazione senza dare una spiegazione di come è effettivamente organizzato un simulatore da un punto di vista generale. Possiamo dire che esso è un oggetto che sfrutta un insieme di tecniche; queste ultime possono essere in contapposizione tra loro (nel senso che se uso una non posso usare un'altra) oppure possono essere contemporanee (entrambe riguardano lo stesso argomento ma non sono esclusive). Le principali tecniche

14

Capitolo 2

Tecniche di Simulazione

che discuteremo riguardano: la valutazione delle porte, la manipolazione del circuito, il trattamento dei guasti e la loro propagazione. La Fig. 2.1 rappresenta l’organizzazione del capitolo in termini di paragrafi riferiti a ciascuna tecnica descritta.

Valutazione descrittori

2.4

Trattamento guasti

2.5

mascheramento

Iniezione fisica

Trasformazione circuito

Circuito Compilato

2.7.2

Circuito Interpretato

2.7.1

Simulazione Seriale

2.6

Simulazione Oblivious

2.8.1

Simulazione Event Driven

2.8.2

2.9.2 Priorità vettori di ingresso

Priorità guasti

2.9.1

Simulazione differenziale

2.10

Simulazione Concorrente

2.12

Simulazione parallela

2.13

Simulazione Deduttiva

2.11

Fig. 2.1: Organizzazione del capitolo

15

Capitolo 2

Tecniche di Simulazione

2.3

Descrizione analitica del circuito

Discuteremo ora della problematica legata alla descrizione di un circuito tenendo ben presente che ciò ci dovrà servire in seguito per la simulazione vera e propria; non parleremo pertanto di simulazione, ma di come descrivere un circuito al calcolatore affinché poi ne possa essere simulato il comportamento. Un circuito logico è costituito da un insieme di nodi, intesi come variabili che possono assumere un valore logico, e da un insieme di porte che effettuano determinate operazioni sui nodi. Occorre a questo punto, per poter poi rendere più comprensibili gli algoritmi che verranno proposti, dare una forma concreta a queste affermazioni, dare cioè una possibile rappresentazione del circuito: i due insiemi di dati, di cui abbiamo prima parlato, saranno quindi implementati con due strutture dati separate: un vettore per contenere i valori dei nodi (stato totale del circuito) e un altro per contenere la topologia del circuito. Quest’ultima è organizzata come un vettore: ogni elemento, che d’ora in poi identificheremo come descrittore, descrive una piccola porzione della rete specificando le relative connessioni con gli altri elementi e l’eventuale operazione logica elementare svolta. L’indice utilizzato per accedere al vettore viene denotato ID1 del descrittore. Per la realizzazione di un tale modello, premettiamo che a ciascun descrittore saranno associati una serie di elementi: • attr: attributo, specifica se il descrittore è un ingresso primario (PI), una porta con uscita primaria (PO) o una porta interna (INT); • type: tipo del descrittore, specifica l’operazione logica svolta; • level: livello logico del descrittore; • fanin: numero di ingressi del descrittore; • fanout: numero di diramazioni dell’uscita; • from: vettore di lunghezza pari a fanin contenente i numeri di identificazione dei descrittori connessi agli ingressi; • to: vettore di lunghezza pari a fanout contenente i numeri di identificazione dei descrittori connessi all’uscita; A ciascun ingresso primario viene associato un descrittore fittizio con attributo PI che non svolge alcuna funzione logica, ma permette di descrivere come gli

1 Numero di identificazione, in generale useremo la notazione ID per riferirci al valore dell’indice di un generico vettore.

16

Capitolo 2

Tecniche di Simulazione

ingressi del circuito sono connessi con altri elementi; a tali descrittori viene assegnato il livello 0. Tutti i flip flop, che compaiono se il circuito da descrivere è di tipo sequenziale, saranno collocati anch’essi al livello logico 0; questa scelta sarà in seguito giustificata quando si parlerà di simulazione. Per tutte le altre porte il livello sarà calcolato come massimo fra i livelli delle porte connesse agli ingressi, più uno. Diversamente da quanto fatto per i descrittori con attributo PI, non viene associato alcun descrittore fittizio con attributo PO, ma tale attributo sarà dato alle porte che si affacciano direttamente all’esterno del circuito. In Fig. 2.2 vediamo un esempio di circuito sequenziale disegnato tenendo conto di quanto detto. La Fig. 2.3 è un esempio di descrizione dello stesso circuito con il modello riportato. Dal punto di vista software lo stato totale del circuito si può immaginare venga memorizzato in un vettore val[], mentre la topologia è memorizzata in un vettore descr[] di dimensione pari al numero di descrittori del circuito (n_descr); ciascun elemento è poi diviso in 7 campi: attr ,type, level, fanin, fanout, to e from, i primi 5 sono variabili di dimensioni opportune, mentre gli ultimi due sono gli indirizzi di due vettori di dimensioni pari a fanin e fanout rispettivamente. Da notare che, con le scelte fatte, ad ogni porta corrisponde un nodo (ricordare i descrittori fittizi); quindi anche il vettore val[] ha dimensione n_descr, e in particolare ci sarà corrispondenza tra gli indici di descr[] e gli indici di val[]. Accanto a queste strutture principali, che sarebbero sufficienti da sole a descrivere completamente il circuito, vengono definite altre strutture di supporto che permettono di accedere più velocemente a determinate informazioni; in particolare si definiscono 3 vettori: • pi_array: contiene i numeri di identificazione di tutti descrittori con attributo PI, ha dimensione n_pi; l’utilità di questo vettore si può vedere quando dobbiamo applicare un pattern di ingresso; senza questa struttura per inserire i valori ai nodi corrispondenti dovremmo scandire tutto il vettore descr[] (con dimensione dell’ordine del migliaio) alla ricerca di quelli con attributo PI, mentre basta scandire pi_array (con dimensione dell’ordine delle decine o al massimo delle centinaia). • po_array: contiene i numeri di identificazione di tutti i descrittori con attributo PO. Questo vettore è comodo per accedere direttamente alle uscite del circuito.

17

Capitolo 2

Tecniche di Simulazione

• ff_array: contiene i numeri di identificazione di tutti i flip flop. Nel caso di circuit combinatori non è usato.

1 2

PI PI

6

7

4

8 PO

5

3

PI

Livello 0

Livello 1

Livello 2

Fig. 2.2: Esempio di circuito sequenziale

i 1 2 3 4 5 6 7 8

attr PI PI PI PO

type INT INT INT FF FF NAND NAND NAND

descr[i] level fanin fanout 0 0 1 0 0 2 0 0 2 0 2 1 0 2 1 1 2 1 1 2 2 2 2 0

from 3 6 3 7 1 2 2 4 5 8

to 6 6 4 7 8 4 5 7 7 5

Fig 2.3: Descrizione analitica del circuito di Fig.2.2

i 1 2

pi_array[i] 1 2 (a)

i 1

po_array[i] 8 (b)

i 1 2

ff_array[i]

4 5
(c)

Tabella 2.4: Strutture di supporto per il circuito di Fig. 2.2

18

Capitolo 2

Tecniche di Simulazione

2.4

Valutazione dei descrittori

La valutazione di un descrittore del circuito è il mattone chiave di tutta la simulazione; infatti è possibile verificare come qualunque simulatore impieghi la maggior parte del tempo di elaborazione a svolgere questa procedura. Tutte le tecniche che vedremo mirano da un lato a determinare quali porte devono essere simulate, e con quale ordine, cercando ovviamente di ridurne al minimo il numero; dall’altro è chiaro che la prima cosa da fare consiste nel migliorare l’efficienza della valutazione della singola porta. Valutare un descrittore significa determinare il valore logico di uscita della porta in considerazione della sua funzione e dei valori applicati agli ingressi che dipendono dal tipo di logica adottata (2 valori: 0/1, 3 valori: 0/1/X, 4 valori: 0/1/X/Z). Di seguito presenteremo le pricipali tecniche al riguardo.

2.4.1 Tavola della verità
Questo metodo discende direttamente dall’idea di funzione logica e, in pratica, consiste nell’ottenere i valori di uscita accedendo a matrici indirizzate con il valore logico degli ingressi2 come mostrato in Fig.2.5. Questo metodo diventa indispensabile per la trattazione di blocchi logici inusuali.

A B
B A

U

A B C

U

0 0 1 1 0 U

1 0 0

B A

C =0

C =1

0

1 0 0 U

0 0 1

1 1 1

0 0 1 0

(a) Matrice bidimensionale

(b) Matrice tridimensionale

Fig. 2.5: Valutazione dei descrittori tramite tavola della verità Vantaggi:

2 La dimensione di queste matrici dipende dal fanin , cioè dal numero di ingressi della porta.

19

Capitolo 2

Tecniche di Simulazione

• Possibilità di realizzare qualunque blocco logico combinatorio, anche estremamente complesso (descrizione funzionale). • Facilità a trattare logiche con più di due valori. Svantaggi: • Lentezza nell’accesso alla matrice. • Preventivo riempimento delle matrici (una o più per ogni tipo di blocco logico) con relativa occupazione in memoria.

2.4.2 Operazioni logiche
Questo metodo sfrutta l’intrinseca capacità del calcolatore di utilizzare gli operatori logici elementari quali AND, OR, NOT, XOR. In Fig. 2.6 è mostrato l’algoritmo in un caso semplificato.

switch descr[i ].type { case AND: nuovo_valore = 1 Per ogni ingresso j della porta i, 0 < i <descr[i ].fanin { ingresso_porta = descr[i ].from[j ] nuovo_valore = nuovo_valore AND val[ingresso_porta] } case OR: nuovo_valore = 0 Per ogni ingresso j della porta i, 0 < i <descr[i ].fanin { ingresso_porta = descr[i ].from[j ] nuovo_valore = nuovo_valore OR val[ingresso_porta] } case:NOT: ingresso_porta = descr[i ].from[0] nuovo_valore = NOT val[ingresso_porta] }

Fig.2.6: Algoritmo per la valutazione del descrittore

20

Capitolo 2

Tecniche di Simulazione

Vantaggi: • L’operazione non necessita di accedere a matrici in memoria. Svantaggi: • Gli operatori logici possono essere applicati solo tra due ingressi alla volta: per porte con fanin maggiore di due, è necessaria l’applicazione degli operatori in cascata. • Non sono espressamente considerati dalla logica del calcolatore i valori incognito (X) e alta impedenza (Z).

2.4.3 Considerazioni sul fanin
Il descrittore, quale modello matematico della porta, per come è stato costruito contiene l’informazione relativa al fanin. Pur restando valida la scomposizione circuitale mostrata nella Fig. 2.7, risulta sicuramente vantaggioso determinare il fanin massimo che ciascuna porta del circuito non può superare, e valutare la funzione logica in dipendenza dal numero di ingresso, accedendo direttamente al caso specifico del descrittore che valutiamo. Disporremo pertanto per ogni descrittore di un insieme di espressioni logiche che lo descrivono, tutte simili, ma con diverso numero di segnali di ingresso: dal minimo (2) al massimo. In sede di valutazione, estrarremo soltanto l’espressione logica con fanin pari a quello della porta specifica presa di volta in volta in considerazione; In Fig. 2.8 presentiamo il relativo algoritmo. Vantaggi: • Accesso immediato all’espressione logica da valutare senza effettuare cicli sul fanin e quindi maggiore velocità. Svantaggi: • Occorre esaminare il circuito e da esso ricavare il valore massimo di fanin per ogni tipo di porta. Il fanin massimo è ovviamente limitato a priori; cambiando il circuito (con fanin massimo maggiore) occorre modificare il programma sorgente. • Nel caso di logica a più di due valori occorre definire più espressioni.

21

Capitolo 2

Tecniche di Simulazione

Fig. 2.7: Scomposizione del fanin

switch descr[i ].type { case AND: switch descr[i].fanin { case 2: x1 = descr[i ].from[0] x2 = descr[i ].from[1] nuovo_valore = val[x1] AND val[x2] case 3: x1 = descr[i ].from[0] x2 = descr[i ].from[1] x3 = descr[i ].from[2] nuovo_valore =val[x1] AND val[x2] AND val[x3] case 4: x1 = descr[i ].from[0] x2 = descr[i ].from[1] x3 = descr[i ].from[2] x4 = descr[i ].from[3] nuovo_valore =val[x1] AND val[x2] AND val[x3] AND val[x4] } case OR: ... case NOT: ... } Fig. 2.8: Valutazione del descrittore tenendo conto del fanin

2.4.4 Valore forzante
Questa tecnica sfrutta le caratteristiche delle porte logiche di possedere ingressi forzanti che vincolano il valore delle uscite indipendentemente dal valore degli altri. Si scandiscono gli ingressi di una porta fino a che non viene trovato un valore forzante, in questo caso il ciclo viene interrotto e imposto il valore sull’uscita. Le regole da seguire sono le seguenti:

22

Capitolo 2

Tecniche di Simulazione

• AND: 0 è forzante su 1 e X X è forzante su 1 • OR: 1 è forzante su 0 e X X è forzante su 0 Per l’operazione di XOR non si può evitare di scandire tutti gli ingressi poiché il risultato (1/0) dipende dalla parità/disparità di 0/1. In Fig. 2.9 è mostrato l’algoritmo nel caso semplificato di logica binaria. Vantaggi: • Va bene nel caso di circuiti con porte a elevato fanin, migliorandone statisticamente la velocità. • Facilità nel trattare le logiche a tre valori. Svantaggi: • Se i valori forzanti si trovano verso ultimi ingressi che vengono esaminati, chiaramente l’aumento di velocità si riduce. • Rispetto al caso precedente occorre sempre eseguire un ciclo per ogni porta considerata.

switch descr[i ].type { case: AND: Per ogni ingresso j della porta i, 0<i <descr[i ].fanin Se ingresso_porta = 0 { nuovo_valore =1 Interrompi il ciclo } case OR: Per ogni ingresso j della porta i, 0<i <descr[i ].fanin Se ingresso_porta = 1 { nuovo_valore = 0 Interrompi il ciclo } case NOT: ingresso_porta = descr[i ].from[0] nuovo_valore = NOT val[ingresso_porta] } Fig. 2.9: Valutazione del descrittore nel caso di logica binaria

23

Capitolo 2

Tecniche di Simulazione

2.4.5 Chiamate a procedure
Una tecnica (che verrà ampiamente descritta in seguito) è quella di esplicitare, descrittore per descrittore, l'operazione che compie insieme alle porte coivolte creando così per ogni porta una espressione "ad hoc". Si costruisce in pratica una procedura differente per ogni porta del circuito Vantaggi: • Viene eliminato l'accesso al vettore descr[] nella valutazione delle porte. • Viene eliminato l'accesso al vettore descr[].from che contiene l’elenco dei segnali di ingresso. • Viene eliminato l'accesso indiretto al vettore che contiene il valore dei nodi. Svantaggi: • È necessario creare a parte un modulo contenente le procedure relative al circuito in esame; il tempo di questa fase di "preprocessing" è considerevole.

2.5

Trattamento dei guasti

Tratteremo alcune tecniche inerenti alla gestione dei guasti. Queste operazioni intervengono solamente nell’operazione di simulazione della macchina guasta; le principali consistono nell’iniezione del guasto e nel prelevamento con o senza eliminazione di questo dalla fault list.

2.5.1 Iniezione dei guasti
Vi sono vari sistemi per memorizzare la presenza di un guasto su una determinata linea. Le tecniche più generali sono: • Iniezione fisica • Mascheramento

24

Capitolo 2

Tecniche di Simulazione

Iniezione fisica Consiste nel modificare direttamente il nodo su cui si vuole inserire un guasto; questo sarà localizzato o sulla uscita di una porta (Stuck-output) o su uno dei suoi ingressi (Stuck-input). Questi ultimi, prima di essere iniettati vengono convertiti nell’equivalente Stuck Output, simulando la porta in questione. L’iniezione viene fatta solamente se il guasto è eccitato. Come si può notare dall’algoritmo di Fig. 2.10 l’analisi di uno stuck-input richiede qualche operazione in più in quanto occorre osservare se il guasto considerato è visto dall’uscita della porta ed è quindi equivalente ad uno stuckoutput. Questa operazione dipende certamente dai valori presenti (cioè generati dalla simulazione dell’ultima macchina buona) e deve essere ripetuta per ogni stuck-input.

Iniezione guasto i: fvalue = valore del guasto fdescr = ID del descrittore su cui è localizzato il guasto ftype = tipo del guasto finput = ID del descrittore collegato all’ingresso Se ftype = STUCK_INPUT Se fvalue != val[finput] allora simula la porta fdescr tenendo conto del guasto -> nuovo_valore Altrimenti guasto non eccitato, interrompi Altrimenti se ftype = STUCK_OUTPUT nuovo_valore = fvalue Se nuovo_valore != val[fdescr] val[fdescr] = nuovo_valore Altrimenti guasto non eccitato Fig.2.10: Algoritmo per l’iniezione fisica di un guasto Mascheramento Per evitare di modificare l’insieme dei valori della macchina buona per inserire il guasto, si può utilizzare un’altra tecnica di memorizzazione, consistente nel creare, accanto a val[], una struttura parallela che, descrittore per descrittore, annoti la presenza dei guasti.

25

Capitolo 2

Tecniche di Simulazione

Da un punto di vista circuitale si può considerare lo schema di Fig. 2.11 nel caso di stuck-output; in pratica non è necessario inserire una nuova porta nel circuito ma basta controllare il vettore di memorizzazione dei guasti, in corrispondenza della porta trattata, e compiere su di essa le operazioni che si farebbero se fosse stata inserita una porta aggiuntiva. La nuova struttura prende il nome di maschera; può essere realizzata in due modi: • con un solo vettore utizzando la proprietà dell’EXOR di essere un NOT pilotabile. In corrispondenza del descrittore guasto viene inserito un 1 in modo da invertire il contenuto di val[fdescr] con l’operazione: val[fdescr] EXOR maschera[fdescr]. indipendentemente dal tipo di stuck-at. L’algoritmo è riportato in figura 2.12. • sdoppiando il vettore: uno per l’inserimento di stuck-at-1, in cui è necessaria l’operazione di OR con il valore di uscita del descrittore e uno per l’inserimento di stuck-at-0 che necessita invece dell’operazione di AND. L’algoritmo è riportato in figura 2.13. val[fdescr] OR maschera_1[fdescr] val[fdescr] AND maschera_0[fdescr] stuck-at-1 stuck-at-0

L’uso delle maschere può essere esteso ai guasti stuck-input se le associamo a ciascun ingresso della porta, ma la complessità e l’inefficienza ne sconsigliano l’utilizzazione. Noi tratteremo solo stuck-output.

1

O
(a) Modello per STUCK_AT_1 (b) Modello per STUCK_AT_0

Fig. 2.11

26

Capitolo 2

Tecniche di Simulazione

Inizializzazione maschere: Per ogni ID_descrittore maschera[ID_descrittore] = 0 fvalue = valore del guasto fdescr = ID del descrittore su cui è localizzato il guasto Costruzione maschere: Se guasto eccitato allora maschera[fdescr] = 1 Iniezione guasto: (Da inserire nella procedura di valutazione descrittori) uscita <- simula la porta nuovo_valore = uscita EXOR maschera[fdescr] Fig. 2.12: Algoritmo mascheramento singolo

Inizializzazione maschere: Per ogni ID_descrittore maschera_0[ID_descrittore] = 1 Per ogni ID_descrittore maschera_1[ID_descrittore] = 0 fvalue = valore del guasto fdescr = ID del descrittore su cui è localizzato il guasto Costruzione maschere: Se fvalue = 1 allora maschera_1[fdescr]= 1 Se fvalue = 0 allora maschera_0[fdescr] = 0 Iniezione guasto: (Da inserire nella procedura di valutazione descrittori) uscita <- simula la porta nuovo_valore = uscita OR maschera_1[fdescr] AND maschera_0[fdescr] Fig. 2.13: Algoritmo mascheramento doppio 27

Capitolo 2

Tecniche di Simulazione

Il metodo del mascheramento è anche utilizzabile con profitto se, con opportuni accorgimenti, vengono inseriti più guasti contemporaneamente (simulazione di guasti multipli e simulazione parallela). Lo svantaggio, rispetto all’iniezione fisica, consiste nell’aggiunta di un’operazione di mascheramento per ogni descrittore valutato. Nel caso di guasti singoli su tutte le porte non interessate dall’iniezione del guasto verrà eseguita l’inutile operazione di AND con 1 ed OR con 0. Per ovviare a questo problema introduciamo un nuovo tipo di descrittore che chiamiamo “F_type” (ad es. all’operazione di AND associamo F_AND come mostrato in Fig. 2.14) che effettuerà l’operazione di mascheramento, fermo restando per gli altri descrittori “type” la semplice valutazione della porta. In questo modo la fase di iniezione di un guasto sull’uscita di una porta i corrisponde all’aggiornamento della/e maschera/e e in una modifica del tipo di i da “type” a “F_type”, in modo che durante la simulazione, e solo per questa porta, venga richiamato il sottoprogramma che realizza la mascheramento. Alla fine della simulazione, bisognerà ripristinare il tipo corretto della porta “F_type”, riconvertendolo in “type”.

switch descr[i ].type { case AND: nuovo_valore = 1 Per ogni ingresso j della porta i, 0 < i <descr[i ].fanin { ingresso_porta = descr[i ].from[j ] nuovo_valore = nuovo_valore AND val[ingresso_porta] } case F_AND: uscita = 1 Per ogni ingresso j della porta i, 0 < i <descr[i ].fanin { ingresso_porta = descr[i ].from[j ] uscita = uscita AND val[ingresso_porta] } nuovo_valore =uscita EXOR maschera[i] } Fig. 2.14: “type” e “F_type”

28

Capitolo 2

Tecniche di Simulazione

2.5.2 Fault list e Fault dropping
I guasti iniettati vengono prelevati da un file costruito preventivamente da un opportuno generatore (Fault generator) che si occupa di dare una descrizione di ogni guasto da considerare. Solitamente a valle di questo programma ve ne è un altro (Fault collapser) che ricava la lista dei guasti ridotta, ottenuta applicando le regole di equivalenza. dalla lista guasti completa3 secondo la descrizione a blocchi di Fig. 2.15.

Generatore di Guasti

n. 1 n. 2 n. 3

Fault Collapser

n. 1 n. 3 n. 5

Modello Circuitale

Lista dei Guasti

Lista dei Guasti Ridotta

Regole di equivalenza

Fig. 2.15 Il file contiene per ogni guasto le seguenti informazioni: • tipo del guasto: stuck-input o stuck-output; • linea di ingresso guasta: esiste solo per lo stuck-input e contiene l’ID del descrittore connesso all’ ingresso sede del guasto; • valore del guasto: 0 oppure 1(se parliamo di logica a due valori); • descrittore guasto: indica il sito del guasto specificando l’ID del descrittore. Questo file è letto dal programma di simulazione ed il suo contenuto è memorizzato in una struttura interna. Una volta rivelato il guasto, volendo migliorare l’efficienza, si può pensare di eliminarlo in qualche modo dalla struttura così da non riprenderlo in considerazione nei passi di simulazione successivi; l’operazione prende il nome di fault dropping, e le strutture che la implementano possono essere differenti. Il notevole vantaggio di questa tecnica è apprezzabile per elevate coperture. La struttura dati per la memorizzazione dei guasti può essere implementata in vari modi:

3 Molte volte questi due programmi sono conglobati in uno solo.

29

Capitolo 2

Tecniche di Simulazione

Con vettore È la struttura più semplice, consiste in un vettore in cui ogni elemento viene suddiviso nei campi descritti sopra. Un ulteriore campo o un vettore parallelo può essere usato per contassegnare i guasti rivelati in modo da non estrarli nelle simulazioni successive. Con lista concatenata L'uso di una struttura dinamica, che si riduca in corrispondenza della rivelazione di un guasto eliminandolo dalla lista, come evidenziato dalla Fig.2.16, ci evita, rispetto al caso precedente, di controllare ogni volta, prima dell’estrazione del guasto stesso, la sua eventuale precedente rivelazione. In certi casi per accedere più facilmente agli elementi la lista può essere doppio linkata bidirezionale come vedremo nel paragrafo 4.4.3.

F1

F2

F3

F4

F5

(a) Struttura dalla Fault List F1 F2 F3 F4 F5

(b) Eliminazione del guasto F

3

dalla Fault List

Fig. 2.16

2.5.3 Ripristino dello stato della macchina buona
Abbiamo visto come l’iniezione di un guasto modifichi lo stato della rete; per poter simulare il guasto successivo è necessario, per ottenere risultati corretti, ripristinare lo stato della macchina buona, ossia eliminare gli effetti del guasto precedente. Questo scopo può essere raggiunto con diverse strategie che si differenziano l’una dall’altra per occupazione di memoria, complessità e velocità di elaborazione: • duplicazione dello stato totale; • iniezione del guasto opposto;
30

Capitolo 2

Tecniche di Simulazione

• memorizzazione dei nodi cambiati; • metodo degli ID. Duplicazione dello stato del circuito buono È il più immediato, dal momento che prevede la costruzione di una copia del vettore contenente il valore logico di tutti i nodi del circuito buono, in modo da poterlo ripristinare prima dell’iniezione di un nuovo guasto. Come sempre alla semplicità si contrappone la bassa velocità causata dall’operazione di ricopiatura di tutti i nodi, indipendentemente dal fatto che siano cambiati o meno.

Simulazione della macchina buona sui nodi gval[] Per ogni guasto i { copia gval[] in fval[] Simulazione della macchina guasta i su fval[] } Fig. 2.17: Duplicazione dello stato della macchina buona Iniezione del guasto opposto Subito dopo aver simulato un guasto, per evitare di dover ricopiare l’intero vettore contenente lo stato, si può pensare di iniettarne uno di valore opposto nello stesso nodo e propagarne gli effetti fino alle uscite, riottenendo così lo stato di partenza. Questa tecnica ha il vantaggio di non usare nessuna struttura ausiliaria, ma implica la risimulazione di un certo numero di porte e raramente può dare risultati vantaggiosi rispetto alle altre tecniche;è stata citata solo per completezza; può essere usata in casi particolari, ad esempio in fase di “debugging” del programma. Memorizzazione dei nodi cambiati È conveniente usarla se ogni passo di simulazione modifica solo una parte del vettore contenente lo stato totale (vedi tecnica Event Driven). Fa uso di una lista ausiliaria LIFO o FIFO dimensionata inizialmente al numero di descrittori della rete. L’idea è quella di salvare, nella suddetta lista, l’ID di un descrittore e il suo corrispondente valore di uscita prima che sia modificato. Una volta effettuata la

31

Capitolo 2

Tecniche di Simulazione

simulazione, basterà estrarre i valori e i nodi preventivamente salvati, ripristinando velocemente la macchina buona, come illustrato in Fig. 2.18.

Fase di memorizzazione: Simulazione del guasto g: : : Inserisci nella lista i e val[i] Modifica il valore di val[i] : : Fase di ripristino: Finché la lista non è vuota { estrai il prossimo nodo estrai il prossimo valore val[nodo] = valore } Fig. 2.18: Memorizzazione dei nodi cambiati Metodo degli ID Questo metodo utilizza tre strutture di dimensioni pari al numero dei descrittori: • un vettore per i nodi della macchina buona; • un vettore per i nodi della macchina guasta; • un vettore con lo scopo di contrassegnare univocamente i nodi il cui valore è diverso nella macchina buona ed in quella guasta. In fase di simulazione di un particolare descrittore, il valore dei nodi di ingresso sarà prelevato o dalla struttura di macchina buona o da quella di macchina guasta in base alle indicazioni fornite dalla terza struttura; se la valutazione di questa genererà un valore di uscita differente dalla macchina buona, anche questo nodo verrà contrassegnato per la valutazione delle porte successive.

32

Capitolo 2

Tecniche di Simulazione

2.6

Simulazione seriale

Consiste nel trasformare il modello di circuito privo di guasti in N modelli ognuno atto a rappresentare il circuito di partenza dopo l’introduzione del generico guasto f. Il processo di modellizzazione deve essere ripetuto per ogni guasto e i guasti sono simulati uno alla volta. Non sono richiesti per questa tecnica speciali simulatori in quanto il circuito dopo la modellizzazione con il guasto viene simulato come la macchina buona. Un grosso vantaggio sta nella possibilità di poter considerare qualunque modello di guasto; pertanto se ad esempio vogliamo rappresentare un cortocircuito tra due linee, è sufficiente realizzare un nuovo circuito in cui quelle specifiche linee sono unite e poi simularlo. È impraticabile per circuiti grandi visti gli enormi tempi di CPU per la costruzione dei nuovi modelli associati ai guasti.

2.7

Implementazione del simulatore

Dal punto di vista dell’implementazione (cioè la traduzione degli algoritmi in un programma) possiamo distinguere due classi di simulatori: di tipo compilativo [Lewi91], che rappresentano la rete generando un codice macchina specifico, e di tipo interpretato che utilizzano una struttura dati per rappresentare il circuito.

2.7.1 Circuito interpretato
Il circuito è rappresentato da una struttura dati ed è possibile attraversarlo sfruttando le informazioni legate ad ogni descrittore. Questa tecnica sfrutta la descrizione del circuito data nel paragrafo 2.3. La simulazione interpretata è poco efficiente dovendo scandire la struttura dati della rete. Questo tipicamente significa eseguire centinaia di istruzioni per la valutazione di ogni elemento, di cui solo poche servono alla effettiva valutazione logica; in particolare si dovrà accedere alla struttura contenente la rete un numero considerevole di volte. I simulatori compilati utilizzano invece una più efficiente strategia implementativa per ridurre questo problema.

33

Capitolo 2

Tecniche di Simulazione

2.7.2 Circuito compilato
Grazie alla generazione “ad hoc” di codice macchina che implementa direttamente l’espressione logica del circuito, è possibile realizzare una simulazione estremamente efficiente per quella particolare rete. Questa può essere vista come un’estrema forma di ottimizzazione del circuito dove tutti i cicli del simulatore sono sviluppati e tutti i dati sono indirizzati direttamente, con solo poche istruzioni richieste per la valutazione di una porta. Per completare il confronto con la tecnica precedente presentiamo un esempio in Fig. 2.19.

1 7 2 5 3 4 6 8

(a) Circuito di esempio
AND NEG OR MOV NEG MOV AND MOV val[2],val[3] A A,val[4] A,val[6] A A,val[8] val[6],val[1] A,val[7]

val[6] = val[4] OR ( NOT( val[2] AND val[3] )) val[7] = val[1] AND val[6] val[8] = NOT val[6]

(c) Pseudo codice (b) Codice macchina

Fig.2.19: Simulazione compilata

2.8

Tecniche di propagazione

Denotiamo con tecniche di propagazione quelle che si occupano dell’accesso ai descrittori del circuito, scegliendo quali valutare e con quale ordine.

34

Capitolo 2

Tecniche di Simulazione

2.8.1 Algoritmo Oblivious
L’algoritmo oblivious è già stato presentato al paragrafo 1.5.1 come esempio più immediato di simulatore; riportiamo ora un algoritmo più particolareggiato che utilizza la struttura dati vista all’inizio del capitolo. Allo svantaggio di questa tecnica per cui l’intero circuito è risimulato senza sfruttare alcuna indicazione sui nodi già valutati, si contrappone il vantaggio di una facile implementazione senza strutture ausiliare per la propagazione. È pertanto utile per verificare in maniera precisa e veloce la correttezza di un circuito, purchè di dimensioni limitate. Riportiamo l’algoritmo base della simulazione oblivious e le procedure per applicare i pattern al circuito.

Per ogni pattern { Applica il pattern Per ogni descrittore i (in ordine di livello crescente) 0<i <n_descr { nuovo_valore <- Valuta il descrittore descr[i ] val[i ] = nuovo_valore } Stampa il vettore di uscita } Fig.2.20a: Simulazione Oblivious

patt_val[i ] <- Legge il pattern dal file 0< i < n_pi Per ogni ingresso i 0 < i < n_pi { descrittore_ingresso = pi_array[i ] val[descrittore_ingresso] = patt_val[i ] } Fig. 2.20b: Applica il pattern

2.8.2 Tecnica Event Driven
L’idea è quella di diminuire il numero di porte che devono essere simulate, valutando solo quelle i cui ingressi sono variati rispetto al passo di simulazione precedente.

35

Capitolo 2

Tecniche di Simulazione

Per implementarla occorre costruire una struttura di supporto che definiremo struttura di propagazione. Nella sua concezione più semplice essa consiste in una serie di liste (di tipo LIFO o FIFO) pari al numero di livelli logici presenti nel circuito; ciascuna lista a sua volta avrà come dimensione massima il numero di descrittori presenti a quel particolare livello, come mostrato in Fig. 2.21.

1 Livello 0 Livello 1 Livello 2 Livello 3 3 4

2 1 8

3 4 2

5

6 7

8

17 6 5

9

7 11 15

Fig. 2.21: Struttura di propagazione Sulla struttura di propagazione vengono effettute due operazioni: • Fase di propagazione Dopo aver valutato una particolare porta la cui uscita è variata (evento), inseriamo nella struttura tutti i numeri di identificazione dei suoi discendenti, ciascuno nella lista avente numero pari al suo livello. • Fase di estrazione Si occupa di estrarre fisicamente (nel senso che vengono cancellati) i descrittori presenti nella struttura di propagazione a partire dalla lista con livello 1. Quando una lista viene svuotata si passa a esaminare quella con il livello successivo; è interessante notare che al termine della simulazione la struttura sarà completamente azzerata e pronta per una nuova simulazione.

36

Capitolo 2

Tecniche di Simulazione

Per ogni pattern { Applica il pattern Per ogni livello 1 _ livello _ max_level finché lista[livello] non è vuota { Estrai il prossimo descrittore i nuovo_valore <- Valuta il descrittore i Se nuovo_valore _ val[i ] cioè si genera un nuovo evento { val[i ] = nuovo_valore Propaga4 (inserisce i figli della porta i nella lista) } } } Figura 2.22 Algoritmo della simulazione Event Driven

Per ogni descrittore j discendente della porta i 0 < j < descr[i ].fanout { ID_figlio = descr[i ].to[j ] livello_figlio = descr[ID_figlio ].level Se present[ID_figlio ] = ASSENTE { inserisce nella lista[livello_figlio ] la porta ID_figlio present[ID_figlio ] = PRESENTE } }

Fig. 2.23: Algoritmo di propagazione L’algoritmo di Fig. 2.22 può essere esteso facilmente ai circuiti sequenziali, notando che per questi ultimi, dopo un passo di simulazione, la lista di propagazione non è vuota, come nel caso dei combinatori, ma contiene gli ID dei flip-flop sui quali si è propagato un evento; questo grazie al fatto che sono stati posti al livello 0 pur essendo i loro ingressi connessi ad un livello superiore. Quindi nel passo di simulazione successivo basterà propagare, oltre al guasto che si vuole iniettare, anche tutti i flip-flop attivi. Possiamo adottare due diversi approcci. Il più semplice, ma meno efficiente, consiste di due fasi di simulazione distinte, una per propagare fino alle uscite i valori dei flip-flop, e l’altra per
4Vedi algoritmo di Fig. 2.23.

37

Capitolo 2

Tecniche di Simulazione

propagare il guasto, iniettandolo sull’ insieme di valori generato dalla prima fase, come illustrato nelle Fig. 2.24 e 2.25.

Fi

Fase 1: applicazione e propagazione flip-flop

Fase 2: iniezione e propagazione guasto Fi

Fig. 2.24 Ci si chiede se sia possibile unificare le due fasi di simulazione (cioè: applicare i flip-flop, iniettare il guasto e con un’unica passata determinare il nuovo stato totale della rete) e, in tal caso, se ciò possa migliorarne l’efficienza.

Reset dei FF: Per ogni flip-flop k 0 < k < n_ff { ID_flip-flop = ff_array[k] val[ID_flip_flop] = 0 Propaga cioè inserisce i figli del flip flop k nella lista di propagazione } Passo di simulazione con pattern i e guasto j Applica il pattern i Applica i valori dei FF ottenuti al passo precedente Simula il circuito (propagando gli eventi fino alle uscite) Inietta il guasto j Simula il circuito (propagando gli eventi fino alle uscite) Verifica rivelazione guasto Applica i valori dei FF: Estrai il prossimo descrittore k dalla lista[0] ID_ingresso_FF = descr[k].from[0] val[k] = val[ID_ingresso_FF] (corrisponde a dare un colpo di clock) Propaga cioè inserisce i figli del flip-flop k nella lista

Fig. 2.25: Algoritmo ED per circuiti sequenziali 38

Capitolo 2

Tecniche di Simulazione

Possiamo subito fare alcune considerazioni: Se i coni di influenza dei flip-flop e del guasto, sono F i disgiunti, possiamo unificare le fasi, ma non otteniamo vantaggi in termini di riduzione degli eventi.
Fi

Se vi è intersezione, l’unificazione permette di risparmiare la rivalutazione delle porte contenute nella regione comune. Se il cono di influenza del guasto è completamente

F i

incluso nei coni di influenza dei flip-flop, la tecnica non può essere adottata senza particolari accorgimenti, poiché la propagazione dei FF potrebbe inporre un valore al nodo l opposto a quello iniettato da Fi, cancellando, di fatto, la presenza del guasto, che altrimenti sarebbe stato attivo.

nodo l

Il problema esposto nella terza considerazione può essere risolto con la tecnica del mascheramento vista al paragrafo 2.5.1; in particolare con il doppio mascheramento, poiché fino al momento della valutazione del descrittore sede del guasto, non conosciamo se il guasto sarà eccitato (con il mascheramento singolo, l’uscita della porta in questione verrebbe comunque invertita, indipendentemente dall’eccitazione).

2.8.3 Confronto tra le due tecniche
Sebbene interpretazione/compilazione e oblivious/event driven siano indipendenti, la maggior parte delle implementazioni di simulatori compilati hanno usato algoritmi di simulazione oblivious (OV), mentre i simulatori interpretativi hanno usato simulatori event driven (ED). Così l’efficienza dell’algoritmo ED è compromessa dalla bassa velocità dell’implementazione interpretativa, mentre la scarsa efficienza dell’algoritmo OV viene compensata dall’alta velocità nella valutazione degli elementi. La scelta del metodo di simulazione dipende dall’attività della rete. Supponiamo che un simulatore ED esegua Ne istruzioni macchina per valutare una porta, che un simulatore OV ne esegua No e che la probabilità che una porta causi un evento durante un passo di simulazione sia p. Il simulatore ED esegue mediamente p Ne istruzioni per porta e per passo di simulazione, mentre il simulatore OV ne esegue No; allora il

39

Capitolo 2

Tecniche di Simulazione

primo sarà più efficiente solo se p < No/Ne. I simulatori ED hanno Ne di diverse centinaia mentre quelli OV compilati hanno No di qualche unità; se ne deduce che la soglia di p sotto cui il simulatore ED interpretato è più efficiente è 1÷2%. Questo basso valore suggerisce che la simulazione ED interpretata è raramente l’approccio più efficiente. Combinando la ED con l’implementazione compilata si riduce il valore di Ne a sole 20÷50, facendo salire il valore di soglia di p al 4÷10 % e rendendo la tecnica più competitiva. Questo sarà visto più nel dettaglio nel paragrafo 3.6.

2.9

Organizzazione dei vettori di ingresso e dei guasti

L’algoritmo di simulazione della macchina guasta è essenzialmente composto da due cicli annidati, si hanno quindi due diverse disposizioni. In un caso vengono considerati tutti i vettori di ingresso in corrispondenza di un unico guasto (priorità di guasti), nell’altro un vettore di ingresso per volta viene applicato a tutte le possibili macchine guaste (priorità di vettori di ingresso). Alla simulazione di macchina guasta è associata la tabella di Fig.2.26 a cui sarà fatto sovente riferimento per rendere più chiari i concetti. Come si può notare le colonne rappresentano stati corrispondenti a macchine diverse con lo stesso vettore d’ingresso mentre le righe hanno in comune il guasto; da notare la prima riga corrispondente alla simulazione buona. V1 good F1 .... Fj Fj+1 .... Fm G1 S1,1 .... Sj,1 Sj+1,1 .... Sm,1 V2 G2 S1,2 .... Sj,2 Sj+1,2 .... Sm,2 .... .... .... .... .... .... .... .... Vi Gi S1,i .... Sj,i Sj+1,i .... Sm,1 Vi+1 Gi+1 S1,i+1 .... Sj,i+1 Sj+1,i+1 .... Sm,i+1 .... .... .... .... .... .... .... .... Vn Gn S1,n .... Sj,n Sj+1,n .... Sm,n

Fig. 2.26

40

Capitolo 2

Tecniche di Simulazione

2.9.1 Priorità di guasti
Si scandisce la tabella per righe, continuando ad applicare i vettori di ingresso su una stessa macchina guasta fino alla rivelazione del guasto considerato. Questo metodo è il più immediato, in quanto la sequenza di test di ingresso viene applicata sullo stesso circuito guasto proprio come si farebbe sperimentalmente. In particolare per i circuiti sequenziali ogni stato futuro generato può essere direttamente trasferito sugli ingressi PPI insieme al vettore successivo. L’inconveniente principale è che i vettori di ingresso possono essere molto diversi tra loro, specie se la loro generazione è casuale, dando ciascuno origine a molti eventi; questo guaio non è rilevante se viene applicata una tecnica OV, mentre diventa assai pesante se usiamo l’ED.

2.9.2 Priorità di vettori d’ingresso
In questo caso è opportuno distinguere la simulazione per circuiti sequenziali da quella per circuiti combinatori. Nel caso dei primi la tecnica ha l’inconveniente di dover rispettare la sequenza dei vettori proposta. Con riferimento alla tabella di Fig.2.26 ogni macchina guasta Fj, provata con il vettore Vi, produce uno stato guasto Sj,i; con il vettore successivo Vi+1 dovrà essere applicato lo stato guasto precedente Sj,i per produrre il nuovo stato guasto Sj,i+1, e così via. Ne concludiamo che per ogni vettore dovranno essere memorizzati un numero pari a n_guasti stati differenti. Questa operazione è tanto più onerosa quanto maggiore è il numero dei flip flop, cioè degli elementi atti a memorizzare lo stato; ovviamente è necessario conservare i valori della macchina buona (almeno quelli dei PO). Siccome l’eccitazione di ingresso non cambia durante la scansione di una colonna, il numero di eventi da propagare sarà limitato, rendendo il metodo ottimale per la tecnica ED. Per i circuiti combinatori questa simulazione è molto efficiente in quanto non esiste il problema di memorizzare gli stati continuando ad essere valido il vantaggio relativo alla propagazione.

41

Capitolo 2

Tecniche di Simulazione

Attività dei FF La struttura che memorizza gli stati dovrà contenere un numero di elementi pari a: (n_ff n_guasti) e tale numero è destinato a crescere notevolmente nel caso di circuiti di medio-grandi dimensioni. Definiamo “attività dei FF” il rapporto tra il numero massimo di FF cambiati per vettore di ingresso e il numero di elementi complessivo della struttura di memorizzazione. Siccome questo numero per i circuiti è dell’ordine del l’1÷10 % (è stato provato sugli ISCAS 89), si ottiene un notevole risparmio di memoria copiando guasto per guasto solo i FF cambiati: a tale scopo si può usare una struttura dinamica di allocamento dei FF di dimensione pari al 10% di quella originariamente prevista.

2.10 Simulazione Differenziale
È una tecnica di simulzione guasti veloce con una minima richiesta di memoria e un piccolo tempo di ripristino della macchina buona. Riferendoci alla Fig. 2.26 non emergono ragioni tali per cui non si possa determinare il vettore Sj+1,i+1 dallo stato di un’altra macchina guasta Sj,i+1 in corrispondenza dello stesso vettore applicato agli ingressi primari. Pertanto possiamo simulare la nuova macchina guasta sulla base delle differenze dei nodi, causate dagli effetti del nuovo guasto, rispetto agli stati del guasto precedente. Inoltre non ci sono evidenze che mostrino che esse Sj+1,i+1 assomigli a Sj+1,i o Gi+1 più di Sj,i+1. Sj+1,i+1 può essere costruita da Sj,i+1 simulando solo le loro differenze. Le differenze degli stati di Sj,i+1 e Sj+1,i+1 sono la successiva differenza agli stati di Sj,i e Sj+1,i che furono ottenuti durante la determinazione di Sj+1,i. Usando la simulazione Event Driven la differenza degli stati può essere ottenuta con un piccolo tempo di simulazione. In relazione al fatto che il nuovo stato è ottenuto da quello del guasto precedente, la fault dropping può creare dei problemi, che vengono tuttavia risolti immagazzinando la differenza di stato del guasto rivelato in quella del prossimo guasto ancora da rivelare. La simulazione guasti procederà allora ripetutamente, per ogni macchina e per ogni vettore di prova, come: _ Gi, S1,i, S2,i, _, Gi+1, S1,i +1, _ L’algoritmo di Fig. 2.27 può meglio descrivere come la tecnica differenziale può essere implementata.

42

Capitolo 2

Tecniche di Simulazione

La quota totale di memoria è quella per memorizzare lo stato della macchina corrente (running copy), delle uscite primarie della macchina buona per la rivelazione del guasto e di tutte le differenze degli stati delle macchine da considerare. Diversamente dalla simulazione concorrente qui vengono memorizzate le differenze relative ai soli stati e non a tutti i nodi del circuito. Se il numero di uscite primarie è grande può essere richiesto un elevato tempo, al fine di comparare tutti i valori delle uscite al termine di ogni simulazione dei guasti, che non può essere trascurato. Per minimizzarlo si può fare uso di un contatore (vedi algoritmo) che è settato a zero subito dopo la simulazione della macchina buona oer ogni vettore di prova; durante la simulazione di quella guasta, se i valori di alcune uscite primarie cambiano, viene contato il numero delle uscite che sono variate. Terminata la simulazione se il contatore è diverso da zero il guasto è rivelato.

Per ogni vettore Vi { Se Vi è il primo vettore allora inizializzazione dello stato del circuito Altrimenti rimozione del precedente guasto iniettato Recupero dello lo stato corrente (legato ai flip flop) Applicazione del vettore Vi agli ingressi primari Simulazione ED Memorizza i valori delle uscite Azzera il contatore delle uscite sensibili Per ogni guasto j non rivelato { rimozione del precedente guasto iniettato iniezione del guasto corrente j Simulazione ED e aggiornamento contatore Se il contatore ha valore positivo allora Elimina il guasto j (fault dropping) } } Fig 2.27: Algoritmo della simulazione differenziale

43

Capitolo 2

Tecniche di Simulazione

2.11 Simulazione Deduttiva
Si realizza con una sola passata per ogni vettore indipendentemente dal numero di guasti simulati, (cioè scandendo la tabella di Fig. 2.26 per colonne). Associa a ciascun nodo una lista che contiene solo i guasti eccitati dal vettore di ingresso considerato, cioè tali per cui la macchina buona e la macchina guasta differiscono. Per ogni porta sarà poi calcolata, senza simulazione, la lista dei guasti di uscita sulla base delle liste di quelli di ingresso, in modo che se un guasto è presente all’ingresso della generica porta e non si propaga all’uscita di questa, oppure, se il guasto è presente su due ingressi della porta e produce eventi contrastanti, non dovrà essere preso in considerazione e comparire nella lista di uscita. Alla lista di uscita dovranno essere aggiunti i guasti già presenti su quel nodo. La Fig. 2.28 e l’algoritmo di simulazione aiutano la comprensione schematica del metodo.

Simulazione macchina buona Per ogni descrittore i Per ogni guasto fj associato al descrittore i Se fj è eccitato inserisci fj nella lista del descrittore i Per ogni livello Per ogni descrittore p { Per ogni ingresso k del descrittore Per ogni elemento ei della lista_ingressi[p,k] Se ei si propaga inserisci ei nella lista_uscita[p] Se p è una uscita primaria Tutti i guasti contenuti in lista_uscita[p] sono rivelati Per ogni descrittore h collegato sull’uscita di p { Cerca il numero d’ordine q dell’ingresso connesso a p aggiungi la lista_uscita[p] alla lista_ingressi[h,q] } } Fig. 2.28: Algoritmo di simulazione deduttiva La propagazione dipende dalla funzione logica del descrittore e dal valore dei nodi della macchina buona secondo le sequenti regole (nell’ipotesi semplificatrice di descrittori con 2 ingressi):

44

Capitolo 2

Tecniche di Simulazione

AND/OR 1 Se l’ingresso non interessato dal guasto è posto al valore forzante, allora il guasto non può propagarsi. 2 Se il guasto è presente su entrambi gli ingressi aventi valori opposti, il guasto si propaga. EXOR 1 Se il guasto è presente su un solo ingresso si propaga 2 Se il guasto è presente su entrambi gli ingressi aventi valori opposti, il guasto non si propaga. NOT 1 Il guasto si propaga sempre. Gli svantaggi di questa tecnica sono la considerevole dimensione delle liste che si dilatano e si restringono in modo imprevedibile e la complessa elaborazione legata alla determinazione delle liste in base alle regole descritte.

2.12 Simulazione Concorrente
La presenza di un guasto in un circuito determina generalmente il cambiamento di pochi nodi rispetto al funzionamento della macchina buona. Su questa osservazione è stata introdotta la simulazione concorrente, peraltro molto simile a quella deduttiva dal momento che entrambe si basano sulla propagazione, dagli ingressi alle uscite, di liste di guasti che vengono associate a ciascun descrittore e, di volta in volta, aggiornate sulla base di regole che enunceremo. Alla simulazione completa della macchina buona segue, per ogni guasto, la simulazione dei soli elementi che possiedono uno stato differente, intendendo per stato l’insieme degli ingressi e dell’uscita relativi a quel particolare elemento. Ad ogni passo costruiremo una lista di stati affiancata ad ogni descrittore, ed ogni elemento di questa lista rappresenterà un possibile guasto, sulla traccia delle seguenti regole: 1 Per ogni porta si devono calcolare gli stati corrispondenti a tutti i possibili guasti che determiniamo in base al vettore applicato ai suoi ingressi (vedi Fig. 2.29a).

45

Capitolo 2

Tecniche di Simulazione

2 Al passo successivo, cioè cambiando il vettore di ingresso, dovremo eliminare dalle liste tutte le porte aventi stato identico a quello della nuova macchina buona. 3 Alla lista si devono aggiungere tutte quelle porte guaste il cui stato differisce dalla nuova macchina buona. 4 Se la macchina buona relativa al nuovo vettore differisce rispetto alla precedente, occorre memorizzare il nuovo evento. Analogamente dovremo fare per le porte guaste che sono cambiate e quindi producono variazioni su quelle direttamente alimentate; aggiungeremo pertanto, nelle liste di queste ultime, quelle guaste che sono cambiate. Tali porte sono poi eliminate se il loro stato coincide con quello della macchina buona (vedi Fig. 2.29b). Si indicherà il generico guasto con il nome del nodo su cui è localizzato seguito da 0 o 1 a seconda del tipo di stuck; così ad esempio D1 significa stuck-at-1 sul nodo D. Si è detto della somiglianza con la simulazione deduttiva, tuttavia tale similitudine si ridimensiona osservando che mentre in quella deduttiva le liste che si propagavano erano indipendenti dal guasto asssociato, in questa è contenuta una maggiore informazione; ne deriva uno snellimento dei tempi di simulazione, ma è richiesto un impiego maggiore di memoria dinamica.

46

Capitolo 2

Tecniche di Simulazione

0 1 1 A1 1 0 B0 0 D1

1

0 0 D0

0

0

1 A1 0 0 B1 1

0

1

0

A=0 B=1 C=0

D=0 E=0

A=0 B=0 C=1

D=1

E=1

1 D1 0 0 C1 1 0 E1 0 1 B0 0 0 1 0 0

0 D0 1 1 0 1 E0 1 0 B1 1 0 A1 1 0 0 0 C0 0 0

(a)

(b)

Fig. 2.29: Simulazione concorrente

47

Capitolo 2

Tecniche di Simulazione

2.13 Simulazione Parallela
Riduce il tempo di calcolo in quanto sfrutta il parallelismo intrinseco dell’unità centrale del calcolatore; noto il numero di bit Nw della parola di memoria, (generalmente 16 o 32), per ogni nodo della rete potremo memorizzare Nw stati differenti, dandoci così la possibilità di simulare Nw macchine (diverse per pattern applicato o per guasto iniettato) simultaneamente. Considerando un insieme di vettori di ingresso e una lista guasti rispettivamente di dimensioni Np ed Nf, i passi di simulazione occorrenti nel caso non parallelo sono Np Nf mentre nel caso parallelo si riducono a Np Nf / Nw. La simulazione della macchina buona merita un discorso a parte, sono possibili due strade: la prima consiste nell’utilizzare, per questo scopo, uno degli Nw bit, scelta che implica la risimulazione della macchina buona ad ogni passo, la seconda invece prevede di utilizzare una simulazione non parallela e un altro vettore per la memorizzazzione dei nodi buoni. Il raggruppamento delle Nw macchine da simulare può essere fatto secondo i criteri di priorità di guasti (parallel pattern) e priorità di pattern (parallel fault)

2.13.1 Priorità di vettori di ingresso
Le Nw macchine rappresentano altrettante situazioni guaste differenti. Per questa simulazione, l’iniezione dei guasti diventa la parte più importante e delicata per due principali motivi. Non è possibile iniettare i guasti fisicamente; questo problema, che era già stato accennato a proposito delle due fasi di propagazione per i circuiti sequenziali con la tecnica Event Driven, viene ora ripreso ed esposto con maggiore precisione attraverso l’esempio di Fig. 2.30 dove, per semplicità, è utilizzato un paralellismo di 4.

48

Capitolo 2

Tecniche di Simulazione

0 1

D1 A 0 0 00 B 1 0 00 C 1 0 00 D2 11 11 10 11 10 11 D3 11 11 11 01 11 01 D4
La presenza del guasto viene cancellata

0 1

0 00 0 0 001 0 00 0

0

A macchina buona B inserimento fisico del guasto nel bit corrispondente C valutazione descrittori

Fig. 2.30 La propagazione deve necessariamente partire dal descrittore sede di uno degli Nw guasti, con livello più basso; questo potrebbe cambiare i valori dei guasti ai livelli successivi, in particolare il guasto sul descrittore D4 è stato eliminato in fase di valutazione della porta. Questo problema è risolto ricorrendo ad un doppio mascheramento. Inoltre, iniettare solo i guasti eccitati comporta la memorizzazione della corrispondenza tra il guasto e il bit in una struttura separata. Un’altra fonte di complicazione deriva dalla memorizzazione degli stati futuri dei flip flop; infatti ogni passo di similazione produrrà Nw stati futuri, che dovranno essere inseriti in una struttura che li immagazzinerà, ognuno in corrispondenza del guasto che lo ha generato; questa operazione di “spacchettamento” si rivelerà il punto critico del sistema in termini di tempo di CPU così come la fase inversa, cioè l’applicazione degli stati ai flip flop. Riportiamo in Fig. 2.31 l’algoritmo relativo alla simulazione parallela con priorità di vettori di ingressi.

49

Capitolo 2

Tecniche di Simulazione

Per ogni vettore di ingresso { Simulazione di macchina buona Finché ci sono guasti i da simulare 0 < i < n_guasti { Fase di costruzione dei pacchetti di Nw guasti: numero_del_bit = 0 Finchè numero_del_bit < Nw e i< n_guasti (controllo per l’ultimo pacchetto) { Se il guasto i non è già stato rivelato { Applica lo stato dei flip flop relativo al guasto i Se lo stato genera eventi oppure il guasto è eccitato { inietta il guasto i sul bit numero_del_bit memorrizza la corrispondenza tra numero_del_bit e guasto i incrementa numero_del_bit } } passa al guasto successivo (cioè incrementa i) } Fase di simulazione macchina guasta: Partendo dal livello 0 Simula il circuito Immagazzina gli stati futuri Controlla le uscite per rivelare i guasti e esegue il fault dropping } } Applicazione dello stato dei flip flop relativo al guasto i Per ogni FF j attivo presente in lista_stati_futuri[i,j ] inserisci il suo valore nel bit numero_del_bit Memorizzazione degli stati futuri: Per ogni FF j su cui si è propagato un evento { per ogni bit k { estrai il valore del bit k dal nodo del FF ricava il numero del guasto g dalla corrispondenza con il bit k inserisci ID del FF e il suo valore in lista_stati_futuri[g,j ] } 50

Capitolo 2

Tecniche di Simulazione

}

Fig. 2.31: Algoritmo di parallel fault

2.13.2 Priorità di guasti
Questo tipo di simulazione fu introdotto per la prima volta da Waicukausky [WEFL85] ed è noto con il nome di PPSFP (Parallel Pattern Single Fault Propagation). L’idea base è quella di simulare contemporaneamente Nw macchine differenti per l’applicazione dei vettori di ingresso invece che per il tipo di guasto iniettato. Funziona molto bene nel caso dei circuiti combinatori poiché, essendo questi privi di memoria, la loro simulazione con un dato vettore di ingresso non dipende dallo stato ricavato con l’applicazione del vettore precedente, ossia non è importante l’ordine con cui passiamo i vettori al simulatore. Questo non è vero nel caso dei sequenziali, e ciò rappresenta il maggior problema per l’estensione della tecnica a quest’ultimi. Infatti l’insieme dei vettori che deve essere simulato deve rispettare una ben precisa sequenza temporale. È evidente che la simulazione parallela, e quindi contemporanea, di un certo numero di vettori di ingresso, non può rispettare, per sua stessa natura, nessuna sequenza temporale. Sembra quindi che dobbiamo abbandonare questa tecnica; in realtà è ancora possibile intraprendere questa strada se sostituiamo ogni stato che deve essere applicato alle PPI con una sua stima più o meno accurata. Sarà quindi compito di un processo iterativo far convergere queste stime ai valori appropriati. Se ne intuisce che il punto chiave di questa tecnica estesa ai sequenziali sta proprio nel processo iterativo, da cui dipende il fatto che la tecnica sia vantaggiosa o meno, rispetto alla simulazione non parallela. Nel terzo capitolo saranno discussi due approcci differenti a questa strategia, PSF e PARIS.

51

Capitolo 3 La Simulazione di Guasti: Stato dell’arte
3.1 Introduzione

Circuiti

In questo capitolo si vuole dare una panoramica generale sui principali simulatori di circuiti guasti che sono stati proposti. Essi adottano le tecniche viste precedentemente, o fanno uso di idee nuove allo scopo di incrementare l’efficienza della simulazione. Di volta in volta ne metteremo in risalto le caratteristiche e i punti salienti, che riassumeremo in una apposita tabella. Come nel resto di questo lavoro, si considereranno solo tecniche relative a circuiti combinatori e sequenziali sincroni descritti a livello di porte.

3.2

PROOFS

PROOFS (Parallel RestOrative Order-indipendent Fault Simulator) è un simulatore che mette insieme alcune delle tecniche esaminate precedentemente, quali la simulazione differenziale, la parallela e la Single Fault Propagation (SFP). Di queste cerca di unire i vantaggi e di sopperire agli inconvenienti che esse presentano singolarmente. L’obiettivo principale che si pone PROOFS e di unire alla minima occupazione di memoria, la massima velocità di esecuzione grazie allo sfruttamento del parallelismo della macchina. Si cerca inoltre di minimizzare il

52

Capitolo 3

La Simulazione di Circuiti Guasti: Stato dell’arte

numero di eventi e semplificare l’implementaziuoine software; il simulatore sfrutta inoltre la priorità di guasti. Esamineremo ora alcuni aspetti e accorgimenti adottati nel simulatore.

3.2.1 Logica del simulatore
Viene utilizzata una logica a 4 valori; sono quindi necessari 2 bit per valore secondo la codifica mostrata nella tabella di Fig. 3.1. Codifica 0 1 X Z 1 0 0 1 0 1 0 1

Fig. 3.1: codifica valori Utilizzando un parallelismo di 32 occorrono quindi 2 parole per memorizzare lo stato di un nodo corrispondente a 32 macchine diverse. Indicando con A=(A1,A2) e B=(B1,B2) lo stato dei due operandi e con V=(V1,V2) il risultato, si ha la tabella di Fig. 3.2. V1 AND OR NOT XOR TRIG BUS A1 | B1 A1 & B1 A2 (A1 & B1) | (A2 & B2) E1 | (A1 & E2) (A1&B1&B2) | (A1&A2&B1) V2 A2 | B2 A2 & B2 A1 (A1 & B2) | (A2 & B1) E1 | (A2 & E2) (A2&B1&B2) | (A1&A2&B2)

Fig. 3.2: Operazioni con codifica a 3 valori La porta tristate ha un ingresso A e un ingresso “Enable” E. L’elemento BUS ha 2 ingressi A e B e si comporta come un “Wired OR”, cioè permette il collegamento diretto tra linee che possono avere uscite ad alta impedenza. Nel simulatore le uscite dei tristate possono connettersi solamente agli elementi BUS.

53

Capitolo 3

La Simulazione di Circuiti Guasti: Stato dell’arte

3.2.2 Simulazione macchina buona
È eseguita con la tecnica Event Driven e i valori buoni sono conservati in una apposita struttura. È da dire che per ogni descrittore sono riservate 5 parole: 2 per lo stato buono, contenenti 32 valori uguali, 2 per lo stato guasto e una contenente l’ID del guasto applicato sul descrittore.

3.2.3 Simulazione macchina Guasta
Consideriamo di seguito le procedure che caratterizzano PROOFS per la simulazione dei guasti: • • • • • eccitazione dei guasti; raggruppamento dei guasti; iniezione del guasto; memorizzazione dello stato; ordine dei guasti.

Eccitazione Guasti Un guasto è inserito solo se produce effetti: per questo simulatore l’analisi del eccitazione prevede una considerazione più fine. In base al substrato su cui si inserisce il guasto, questo può essere o non eccitato, oppure esaurire i suoi effetti entro uno o due livelli successivi. La Fig. 3.3 è esplicativa a proposito di questo fatto:

S_a_0 0

S_a_0 1 0 1 1

S_a_0

0

1 (a) (b) (c)

Fig. 3.3

54

Capitolo 3

La Simulazione di Circuiti Guasti: Stato dell’arte

• (a) il guasto non è eccitato e quindi viene scartato; • (b) il guasto è eccitato e inserito nel gruppo da simulare; • (c) il guasto è eccitato, ma i suoi effetti non riescono a propagarsi oltre il livello successivo, viene pertanto scartato. L’analisi sperimentale mostra che l’eliminazione dei guasti inattivi ai livelli successivi fa risparmiare tempo, in quanto vengono valutate meno porte; occorre naturalmente eseguire più controlli, in particolare questo test non deve essere fatto per i descrittori in prossimità delle uscite. Raggruppamento dei guasti. I guasti eccitati vengono raggruppati in pacchetti da 32 e associati ad un numero di identificazione (ID) con cui viene marchiato, nella appositta struttura, il descrittore sede del guasto. L’ID viene incrementato ad ogni pacchetto. Valutazione delle porte Per evitare di ripristinare dopo ogni passo di simulazione la macchina buona, si utilizza la seguente strategia: • La simulazione di ogni pacchetto sarà caratterizzata da un ID. • Si parte con un vettore contenenente lo stato del circuito buono, un vettore di appoggio conterrà, per ogni nodo, l’ID del passo di simulazione in cui è stato modificato. • I descrittori che hanno l’ID più alto, pari a quello della simulazione corrente, sono quelli su cui è inserito il guasto, o quelli variati a causa degli effetti della propagazione di un guasto appena inserito. • Per ogni porta si prelevano i valori dei nodi di ingresso utilizzando il valore guasto se il numero d’ordine della simulazione coincide con il numero del campo ID, il valore buono viceversa. • Il valore così calcolato verrà scritto nella parola riservata alla macchina guasta in corrispondenza del nodo di uscita e la porta valutata assumerà ID pari a quello della simulazione in corso.

55

Capitolo 3

La Simulazione di Circuiti Guasti: Stato dell’arte

L’esempio di Fig. 3.4 chiarisce la regola per un parallelismo di tre.
F
001 100

G 000 111
000 111

ID
4

F
110 001

G 111 000

ID
4

010 001
100 001

3
4

111 000

Fig. 3.4 Iniezione guasto Si realizza cambiando la descrizione interna del circuito inserendo cioè porte AND (stuck-at-0) e OR (stuck-at-1) e associando ad esse una maschera predeterminata per l’inserimento del guasto sul bit considerato, come in Fig. 3.5. Segue la rivalutazione di un nuovo circuito con più descrittori, in particolare quelli con valore predeterminato hanno l’ID corrente che verrà poi propagato. Memorizzazione dello stato Una lista “linkata” che contiene i valori dei nodi di stato (flip flop) è associata con i guasti non ancora rivelati. Questi valori, come già detto, sono inseriti sulle PPI insieme al vettore di ingresso successivo in corrispondenza dello stesso guasto. Da notare che in questo modo la struttura che immagazzina gli stati si riduce con l’eliminazione progressiva dei guasti dalla fault list, come si può notare in Fig. 3.6.

56

Capitolo 3

La Simulazione di Circuiti Guasti: Stato dell’arte

0 1 2

3
0 0

4

5
1

6

Considero i guasti nell'ordine s_a_0 su 3 s_a_1 su 5 s_a_0 su 1

0 1 1' 3 3' 011 110 2 010 5 4

5' 6

Fig. 3.5

Fault List
ID dei guasti

1

2

5

33 45

0 1

88 56

1 1

12 16

0 1

ID del flip flop

Valore del flip flop

Liste per la memorizzazione dei FF attivi

Fig. 3.6:Fault list e strutture annesse per la memorizzazione degli stati Ordine dei Guasti L’ordine con cui i guasti sono passati al simulatore influisce sul numero di eventi; si possono pertanto raggruppare nello stesso pacchetto i guasti correlati,

57

Capitolo 3

La Simulazione di Circuiti Guasti: Stato dell’arte

così da ridurre il numero di porte da valutare. La correlazione si verifica ad esempio per i guasti su una stessa porta o su descrittori in cascata essendo probabilmente simili i loro percorsi di propagazione. I principali ordinamenti sono: • Random:: ordinamento casuale. • In profondità, partendo dagli ingressi: i guasti vengono inseriti nella fault list utilizzando una delle classiche procedure di attraversamento del grafo che costituisce la descrizione topologica del circuito. • In profondità, partendo dalle uscite: analogo al precedente ma utilizza come radice le uscite primarie. • Per livello: i guasti sono inseriti nella fault list a partire da quelli sui descrittori a livello più basso e si procede man mano con i livelli successivi. I risultati sperimentali mostrano che il secondo metodo è più funzionale in termini di tempo; tuttavia adottando la fault dropping, dopo pochi vettori i guasti diventano scorrelati e l’eccitazione può far sì che guasti vicini non siano associati allo stesso pacchetto.

58

Capitolo 3

La Simulazione di Circuiti Guasti: Stato dell’arte

3.2.4 Scheda riassuntiva di PROOFS

Nome: PROOFS Autori: T.M. Niermann, W.T.Cheng, J.H. Patel Logica: 01XZ Modello circuitale:

Riferimento: Ritardo: Modello a ritardo zero
COMBINATORIO SEQUENZIALE
NO SI

[NCPa92]

PORTE CLASSICHE ALTRO

TRIG, BUS

Simulazione guasti:
Implementazione: Tecniche adottate: Idea innovativa:

STUCK_AT ALTRO FAULT DROPPING

INTERPRETATA COMPILATA PARALLELA

Ripristino Good:

Metodo degli ID

Differenziale, PPSFP Eccitazioni su più livelli, metodo degli ID

59

Capitolo 3

La Simulazione di Circuiti Guasti: Stato dell’arte

3.3

PSF

PSF (Parallel Sequence Fault simulator ) è un simulatore parallelo che utilizza la priorità di guasti; costruendo cioè i pacchetti con macchine differenti per l’applicazione dei vettori di ingresso invece che per guasto iniettato.

3.3.1 Divisione delle sequenze
Poiché ogni macchina necessita dello stato dei flip flop determinato con il vettore di ingresso precedente, è evidente che non possiamo includere nello stesso pacchetto macchine aventi sequenze di ingresso consecutive. Dividiamo allora l’intera sequenza di collaudo in Nw sottosequenze, le quali saranno simulate in parallelo come mostrato in Fig. 3.7.
i

S1

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

T1
f S1

S2

i

Considerando parallelismo 3 spezziamo la sequenza T in 3 sottosequenze T 1, T 2 , T 3 ; i raggruppamenti saranno:

T2 S2
f

S3

i

T3
f S3

pacchetto 1: pacchetto 2: pacchetto 3: pacchetto 4: pacchetto 5: pacchetto 6:

1 2 3 4 5 6

7 8 9 10 11 12

13 14 15 16 17 18

Stato iniziale

Stato Finale

Fig. 3.7: Suddivisione delle sequenze Rimane comunque il problema dello stato iniziale di ogni sottosequenza1, poiché esso dovrebbe essere posto uguale allo stato finale della sottosequenza precedente; essendo questa simulata in parallelo, non è possibile conoscerlo a priori; lo stato iniziale sarà quindi posto ad un valore indeterminato.

1Tranne la prima a cui possiamo applicare lo stato di RESET

60

Capitolo 3

La Simulazione di Circuiti Guasti: Stato dell’arte

3.3.2 Procedimento iterativo
Facciamo ora alcune considerazioni sugli stati non completamente specificati: 1 Un vettore A, non completamente specificato, si dice coprire un vettore B se il vettore B è incluso in A; cioè il vettore B è uno dei possibili vettori ottenuti assegnando 1 oppure 0 ad ogni X presente in A. 2 Sia Si lo stato iniziale da applicare assieme al vettore di ingresso V e sia Sf lo stato finale che si ottiene dopo la simulazione; allora, se consideriamo uno stato iniziale Si,’ non completamente specificato e coprente Si, otterremo uno stato finale Sf’ non completamente specificato e coprente lo stato Sf. Questo, in altre parole significa che i valori determinati (1 e 0) presenti in Sf’ sono proprio quelli che si otterrebbero con l’applicazione di Si. Queste considerazioni ci permettono di utilizzare un procedimento iterativo: partendo da stati iniziali indeterminati, dopo una simulazione completa di tutte le sottosequenze otterremo stati finali non completamente specificati, i quali saranno utilizzati come stati iniziali per una nuova simulazione completa che produrrà a sua volta altri stati finali maggiormente specificati rispetto a prima. Iterando il procedimento n volte, gli stati convergeranno ai valori corretti. La Fig. 3.8 può essere utile a capire il concetto. La simulazione viene detta stabile quando il valore dello stato finale di ogni sottosequenza rimane uguale al valore che possedeva al passo di iterazione precedente. Nella peggiore delle ipotesi gli stati convergeranno dopo Nw passi, non presentando così nessun vantaggio rispetto alla simulazione non parallela; fortunatamente questa situazione è abbastanza improbabile dato che normalmente sono sufficienti poche iterazioni per raggiungere una situazione stabile.

61

Capitolo 3

La Simulazione di Circuiti Guasti: Stato dell’arte

Iterazione 1 Stato iniziale T1 T2 T3 Stato finale

Iterazione 2 Stato iniziale Stato finale

Iterazione 3 Stato iniziale Stato finale
f

Reset X X

S 1 (1) S 2 (1) S 3 (1)
f f

f

Reset S2 (2) S3 (2)
i i

S 1 (2) S 2 (2) S 3 (2)
f f

f

Reset S 2(3) S 3(3)
i i

S1 (3) S2 (3) S3 (3)
f f

Fig. 3.8: Procedimento di iterazione

3.3.3 Simulazione di macchina guasta
Per quanto riguarda la simulazione dei guasti, non è necessario aspettare la stabilità del sistema: se esiste una uscita primaria determinata (cioè con valore 1 o 0) differente dal valore della macchina buona, che deve essere anch’esso determinato, il guasto viene rivelato nonostante esistano altre uscite primarie o pseudo primarie poste al valore X. Viceversa per dire che un guasto è non rivelabile è necessario attendere la stabilità sia della macchina buona che della macchina guasta. Per determinare la stabilità della macchina guasta PSF usa la seguente strategia: indicando con Cd e Cx rispettivamente il numero di uscite determinate ed il numero di uscite indeterminate differenti dalla macchina buona stabile, PSF calcola i valori di questi due contatori per ogni guasto. Se Cd e Cx sono uguali a quelli calcolati al precedente passo di simulazione, la stabilità è stata raggiunta. Questo evita di dover memorizzare la lista degli stati della macchina buona.

3.3.4 Conclusioni
È interessante analizzare le prove condotte su PSF con vettori generati in maniera diversa. Lo scopo è stabilire statisticamente quante iterazioni sono necessarie per raggiungere la stabilità, sia nel caso di circuito buono che in quello di macchina guasta. Con la generazione casuale dei vettori di prova, il numero medio di iterazioni per la macchina buona è circa 2, mentre per la macchina guasta il numero è leggermente più elevato (circa 2.1÷ 2.2); questa differenza è dovuta al

62

Capitolo 3

La Simulazione di Circuiti Guasti: Stato dell’arte

fatto che la stabilità della simulazione guasta viene raggiunta solamente dopo che si è raggiunta la stabilità di quella buona. Viceversa se i vettori di prova sono generati in modo mirato (con un ATPG) il numero di iterazioni cresce, e può variare da un minimo di 2 ad un massimo di 20.

3.3.5 Scheda riassuntiva di PSF

Nome: PSF Autori: Chen-Ping Kung e Chen-Shang Lin Logica: 01X Modello circuitale:

Riferimento: Ritardo: Modello a ritardo zero
COMBINATORIO SEQUENZIALE
NO SI

[KuLi92]

PORTE CLASSICHE ALTRO

Simulazione guasti:
Implementazione: Tecniche adottate: Idea innovativa:

STUCK_AT ALTRO FAULT DROPPING

INTERPRETATA COMPILATA PARALLELA

Ripristino Good:

Non specificata

PPSFP Simulazione parallela di sottosequenze

63

Capitolo 3

La Simulazione di Circuiti Guasti: Stato dell’arte

3.4

PARIS

PARIS (PARallel Iterative Simulator) è un simulatore che sfrutta la tecnica nota come Parallel Pattern Single Fault Propagation (PPSFP) [WEFL85]. Questo approccio alla simulazione consiste nell’applicare 32 vettori di ingresso contemporaneamente su un’unica macchina guasta così da sfruttare il parallelismo del calcolatore. Come abbiamo già avuto modo di dire, sono richieste più iterazioni prima di identificare univocamente lo stato della macchina relativo ai diversi vettori applicati, in quanto ogni vettore necessita dello stato ottenuto con quello precedente.

3.4.1 Logica del simulatore
Viene assunta una logica a 3 valori (0, 1, X). Sebbene con tale scelta la codifica necessita di due bit per simbolo, si farà riferimento al simbolo come a un bit. Parola di stato Associata ad ogni segnale del circuito esiste una parola di stato, questa rappresenta il valore del segnale durante 32 cicli di clock, cioè dopo ognuno dei 32 colpi di clock attraverso i quali vengono applicati i vettori di ingresso. Assumeremo che il bit meno significativo della parola corrisponda al primo vettore del pacchetto sia situato all’estremità destra della parola. Stato del circuito Lo stato del circuito si dice consistente se non esiste alcun componente la cui valutazione sia causa di un cambiamento dello stato stesso, ossia quando il processo iterativo converge ad una situazione di stabililtà.

3.4.2 Simulazione di macchina buona
Innanzitutto i valori degli ingressi PPI vengono posti al valore X per tutti i 32 bit. Vengono poi applicati i vettori di ingresso e valutati con una tecnica Event

64

Capitolo 3

La Simulazione di Circuiti Guasti: Stato dell’arte

Driven tutti i nodi del circuito, che possono così assumere un valore noto o incognito. Le successive operazioni consistono nel far scorrere verso sinistra tutti i bit delle parole contenute agli ingressi dei flip flop (PPO), che verranno applicate ai PPI in modo da associare al vettore di ingresso corrente lo stato valutato al passo precedente (ancora non completamente specificato); dopodiché si procede ad una nuova propagazione degli eventi. Questa tecnica può essere schematizzata come in Fig. 3.9.

1° Pacchetto

1° Vettore

2° Vettore

3° Vettore

4° Vettore

RETE

RETE

RETE

RETE

Al 5°vettore nel 2°pacchetto

Fig. 3.9 Utilizzando questa strategia occorre adottare i seguenti accorgimenti: • Per il primo pacchetto, lo shift a sinistra fa sì che il bit meno significativo (LSB) diventi indefinito e debba quindi essere rappresentato con una X. • Il bit più significativo (MSB) definisce il valore di uscita dei flip flop in corrispondenza del primo vettore del pacchetto successivo e deve pertanto essere salvato per inizializzare il passo di simulazione seguente (con un nuovo pacchetto). • Questo processo di iterazione deve essere continuato finché lo stato del circuito non diventa stabile e di conseguenza il numero di iterazioni non è valutabile a priori.

65

Capitolo 3

La Simulazione di Circuiti Guasti: Stato dell’arte

c
Iterazione 3 Iterazione 2 Iterazione 1
01 00 1011 1X 1 1 1 0 11X 1 X1 1X X X X XX

(a) Primo passo di simulazione c
Iterazione 3 Iterazione 2 Iterazione 1
11 00 10 1 1 X01 1 XX 1 1 1 0 11 1 X X11 1 X XX X 1

(b) Secondo passo di simulazione

Fig. 3.10 Con tutte queste iterazioni viene perso, almeno in parte, il vantaggio della simulazione parallela che valutava tutti i descrittori di 32 macchine in una sola passata. Vedremo ora due accorgimenti che rendono PARIS competitivo. Approssimazione delle parole di stato Siccome il meccanismo di simulazione Event Driven garantisce che uno stato iniziale qualunque possa essere trasformato in uno stato finale consistente, si può associare ai PPI una parola di stato arbitraria; una scelta ragionevole è quella di non cambiarla passando ad un nuovo pacchetto e di inserire come nuovo LSB l’MSB valutato precedentamente come mostrato in Fig. 3.11 in relazione al caso presentato in Fig.3.10.

66

Capitolo 3

La Simulazione di Circuiti Guasti: Stato dell’arte

Iterazione 1

1 10 0

1 0 11

1 01 11

Fig. 3.11 I vantaggi consistono nel non dover reinizializzare tutte le parole di stato e nella riduzione notevole del numero di iterazioni, poiché in generale le vecchie parole di stato sono una migliore stima di quelle nuove rispetto ad un insieme di parole incognite. Strutturazione del circuito Un’altra causa di inefficienza sta nel fatto che le porte coinvolte nel processo di iterazione non sono la totalità ma solo quelle che si trovano all’interno dell’anello di reazione. Scomponiamo il circuito in tre parti denominate A, B, C, utilizzando le seguenti regole: 1 tutti i PI appartengono ad A; un componente con tutti i predecessori in A appartiene ad A; 2 tutti i PO appartengono a C; un componente con tutti i successori in C appartiene a C; 3 tutti i componenti che non sono nè in A nè in C appartengono a B. Il circuito risulterà diviso nei tre insiemi disgiunti di Fig. 3.12.

67

Capitolo 3

La Simulazione di Circuiti Guasti: Stato dell’arte

PI
RETE TIPO A RETE TIPO B RETE TIPO C

PO

FF
CK

Fig. 3.12 È perciò sufficiente valutare un componente in A o C su cui si propaga un evento una volta sola e restringere la valutazione delle iterazioni ai soli elementi in B. La simulazione in PARIS si sviluppa quindi in tre fasi principali. • Simulazione di A • Simulazione iterata di B finche lo stato diventa consistente • Simulazione di C

3.4.3 Simulazione macchina guasta
La simulazione di macchina guasta utilizza una tecnica di valutazione dei descrittori e ripristino della macchina buona che utilizza il metodo degli ID in maniera simile a quanto visto in PROOFS. Una volta iniettato lo stesso guasto su tutte le 32 macchine, viene riutilizzata la logica di simulazione già esaminata. Propagazione dei guasti La propagazione degli effetti dei guasti avviene in due modi sostanzialmente diversi: • Attraverso il circuito, se il guasto genera effetti nella rete a partire dal nodo su cui è localizzato.

68

Capitolo 3

La Simulazione di Circuiti Guasti: Stato dell’arte

• Da pacchetto a pacchetto, in quanto l’MSB di tutti i flip flop può essere affetto dal guasto al termine del pacchetto di vettori di ingresso precedente. Nel secondo caso, se consideriamo la parte B, abbiamo il problema di impostare i 31 bits della parola di stato per i flip flop. In questo caso si può scegliere tra le parole della macchina buona che si erano ottenute al termine del pacchetto che ora si vuole considerare e quelle della macchina guasta ricavate al termine del pacchetto precedente. PARIS risolve questo problema calcolando la distanza di Hamming2 che esiste tra le parole in questione; questa è una buona misura di quanto gli effetti del guasto si sono propagati. Se questo numero è minore di una soglia (5) si utilizzano le parole della simulazione buona, viceversa si considerano quelle guaste precedenti. In alcuni casi è possibile che la scelta effettuata con questo criterio non si riveli giusta, cioè non si riesca a raggiungere uno stato consistente anche dopo numerose iterazioni; occorre in questo caso usare le parole scartate e risimulare il pacchetto. Fortunatamente si rileva sperimentalmente che questo caso è estremamente raro.

3.4.4 Limitazioni del simulatore PARIS
PARIS si rivela efficiente se occorre simulare un elevato numero di vettori di ingresso, in quanto il simulatore ne applica 32 insieme. I problemi sorgono quando vi sono pochi vettori, in particolare quando i primi rivelano molti quasti; in questo caso infatti i dati sperimentali confermano che un altro simulatore a priorità di guasti ma non parallelo ottiene risultati paragonabili e su certi circuiti migliori. Questo comportamento è imputabile al fatto che se con un vettore rivelo un guasto devo comunque simulare gli altri 31 ad esso associati, che provocano un considerevole numero di eventi inutili; al contrario con un simulatore a priorità di vettori di ingresso quando si rivela un guasto si può fare immediatamente il Fault dropping. I risultati sono apprezzabili se le coperture non sono elevate in quanto molti guasti restano non rivelati.
2La distanza di Hamming tra due parole binarie si calcola facendone l’EXOR e contando il numero di “1” presenti nel risultato.

69

Capitolo 3

La Simulazione di Circuiti Guasti: Stato dell’arte

Riguardo all’occupazione della memoria occorre fare due considerazioni contrastanti: da una parte non occorre memorizzare alcuno stato da trasferire ai passi successivi, dall’altra ogni segnale occupa più memoria rispetto ad un simulatore non parallelo (16 bit/segnale contro 2).

3.4.5 Scheda riassuntiva di PARIS

Nome: PARIS Autori: Nikolaus Gouders, Reinhard Kaibel Logica: 01X Modello circuitale:

Riferimento: Ritardo: Modello a ritardo zero
COMBINATORIO SEQUENZIALE
NO SI

[GoKa91]

PORTE CLASSICHE ALTRO

Simulazione guasti:
Implementazione: Tecniche adottate: Idea innovativa:

STUCK_AT ALTRO FAULT DROPPING

INTERPRETATA COMPILATA PARALLELA

Ripristino Good:

Non specificata

PPSFP Approssimazione parole di stato Scomposizione del circuito

70

Capitolo 3

La Simulazione di Circuiti Guasti: Stato dell’arte

3.5

HOPE

Come PROOFS anche HOPE è basato sulla propagazione del guasto singolo e adotta il modello a ritardo zero. L’idea base è quella di isolare i guasti con piccoli percorsi di propagazione, in modo da ridurre drasticamente il numero di guasti simulati in parallelo e, dunque favorire una sostanziale accelerazione. Sono considerate di seguito logiche a tre valori (0, 1, X) e di conseguenza anche guasti stuck-at-0/1/X. Avremo pertanto su ogni nodo della rete al massimo la presenza di due guasti eccitati. In particolare il guasto stuck-at-X può verificarsi quando il valore di alcune PPI si trovano allo stato sconosciuto.

3.5.1 Regioni libere da fanout
Ogni volta che si incontrano diramazioni nella parte combinatoria della rete, si provvede alla loro rimozione partizionando la rete in regioni libere da fanout, cioè prive di diramazioni, dette FFR (Fanout Free Regions)[Hong78]. L’uscita s di ogni FFR, che sarà comunque unica, potrà essere una diramazione, una uscita primaria o una uscita pseudo primaria, e sarà indicata come FFR(s). La Fig. 3.13 rende più comprensibile il procedimento di scomposizione di una generica rete in regioni libere da fanout.

3.5.2 Linea dominante
Una linea k si definisce dominante di una linea l se ogni cammino che si diparte da l passa attraverso k. Ne consegue che l’uscita di una FFR è sicuramente dominante rispetto a qualunque linea interna alla regione. Se ci riferiamo alla Fig. 3.13, tutti i cammini dalla diramazione i passano attraverso le linee n e p: se ne conclude che n e p sono linee dominanti della diramazione i.

71

Capitolo 3

La Simulazione di Circuiti Guasti: Stato dell’arte

a= 0
1

b= 0
1

j
1 i

l m
1

0

n e
0

p
1

r

t
0

k

c= 0 d PPI

PPO CK

q

a) Circuito sequenziale

a d b c

FFR(i) j i k

FFR(p) l FFR(t) n m e p r t

q FFR(q) b) Scomposizione della rete combinatoria in FFR

Fig. 3.13

3.5.3 Riduzione dinamica dei guasti
Obiettivo fondamentale di questo simulatore è la riduzione dei guasti che devono essere esplicitamente simulati, nonchè l’incremento dell’efficienza di propagazione. Si consideri la FFR di Fig. 3.13 con i guasti a/1, b/1, c/1, d/0; osserviamo che gli effetti di b/1 si propagano fino all’uscita e precisamente sulla linea t, mentre quelli degli altri si fermano alle uscite delle porte immediatamente successive. L’uso di un pacchetto con i quattro guasti spreca di fatto i bit del pacchetto corrispondenti ai guasti che non si propagano e che potrebbero essere assegnati ad altri. Pertanto se i guasti con breve percorso propagativo sono identificati in una fase iniziale e non inseriti nel pacchetto, si ottiene una

72

Capitolo 3

La Simulazione di Circuiti Guasti: Stato dell’arte

riduzione dello spreco, e questa è la strategia seguita da HOPE con l’impiego delle FFR. Se applichiamo un vettore all’ingresso del circuito, un guasto f, in base agli effetti prodotti, apparterrà ad una delle seguenti categorie: • guasto che si propaga solo sui PO (SEF Single Event Fault) • guasto che si propaga anche sui PPO (MEF Multiple Event Fault). Ovviamente non tutte le volte gli effetti di un guasto raggiungono i PPO, e pertanto diciamo che uno stesso guasto può essere un SEF per alcuni passi di simulazione e un MEF in altri.

3.5.4 Gruppi di equivalenza e pseudo guasti
Dal punto di vista della rivelazione dei guasti, sfruttando il concetto di FFR possiamo affermare che un qualunque guasto posto all’interno di tale regione, se si propaga deve necessariamente trasmettere i suoi effetti sull’uscita della regione. Una conseguenza è che ogni FFR può essere trattata come un circuito combinatorio a se stante; in particolare se un guasto nella regione non è causa di variazioni sull’uscita della FFR si può dire che esso non è eccitato, viceversa gli effetti vengono trasmessi alla FFR successiva; in questo secondo caso l’effetto del guasto sull’uscita della FFR prende il nome di pseudo guasto. Quindi l’insieme dei guasti prelevati dalla fault list, appartenenti alla FFR e tali che i loro effetti si propagano fino all’uscita, costituisce una sorta di classe di equivalenza.

3.5.5 Costruzione dei pacchetti di guasti
Le considerazioni precedenti ci consentono di distinguere la fase di costruzione dei pacchetti di guasti nelle seguenti parti: • Per ogni FFR(s) si considerano tutti i guasti eccitati e propagati con la single fault propagation fino all’uscita. Si controlla quali guasti sono rivelati e si rappresentano con lo pseudo guasto su s denominato fs.

73

Capitolo 3

La Simulazione di Circuiti Guasti: Stato dell’arte

• Se s non ha dominanti e se fs non è già stato simulato in qualche pacchetto precedente, si inserisce fs nel pacchetto corrente per essere simulato in parallelo. • Se la linea s ha un dominante p allora fs si propaga ulteriormente attraverso la FFR(p); se gli effetti di fs arrivano a p allora fs, insieme ai guasti che rappresenta, diventa equivalente a fp . A questo punto se fp non è un PO o un PPO, oppure non è già stato simulato in pacchetti precedenti, è inserito nel pacchetto corrente per essere simulato in parallelo; confronta Fig. 3.14. • Se un generico guasto è iniettato su una linea che non ha dominanti allora quel guasto è inserito direttamente nel pacchetto per essere simulato in parallelo; confronta Fig. 3.15.

FFR(p) a 1/0 s_a_0 c m 1/0 0 l 1/0 0/1 n e 1/0 p

FFR(q)

s

Fig. 3.14

74

Capitolo 3

La Simulazione di Circuiti Guasti: Stato dell’arte

1

1/0 PO t

1/0 s s_a_0

0 0 u PPO

Fig. 3.15

3.5.6 Fase di simulazione e rivelazione
HOPE propone solo una strategia di riduzione dei guasti da simulare in parallelo; una volta costituiti i pacchetti, la simulazione viene effettuata con il metodo PPSFP. La rivelazione di uno pseudo guasto implica la rivelazione di tutti i guasti da esso rappresentati. È da notare che questa tecnica ha una certa affinità con la simulazione deduttiva per via delle liste associate agli pseudo guasti.

3.5.7 Scheda riassuntiva di HOPE
Nome: HOPE
Autori: Hyung Ki Lee e Dong Sam Ha Logica: 01X Modello circuitale: Ritardo: Modello a ritardo zero
COMBINATORIO SEQUENZIALE
NO SI

Riferimento:

[LeHa92]

PORTE CLASSICHE ALTRO

Simulazione guasti:
Implementazione: Tecniche adottate: Idea innovativa:

STUCK_AT Stuck_at_X ALTRO FAULT DROPPING

INTERPRETATA COMPILATA PARALLELA

Ripristino Good:

Non specificata

SFP, PPSFP Regioni libere da fanout

75

Capitolo 3

La Simulazione di Circuiti Guasti: Stato dell’arte

3.6

TORTLE_C

TORTLE_C è un simulatore di macchina buona, a ritardo unitario, per circuiti combinatori; ci si può allora chiedere perché venga riportato, dal momento che, come abbiamo specificato nel Cap. 1, ci occupiamo esclusivamente di simulazione di guasti per circuiti sincroni. La spiegazione sta nel fatto che TORTLE_C è un simulatore compilato, e le tecniche che l’autore espone possono essere facilmente estese al caso dei circuiti sequenziali e al trattamento dei guasti, secondo quanto presentato nel Cap. 4 del presente lavoro. Sostanzialmente TORTLE_C (TORonTo Logic Evaluator Compiled) è un simulatore Event Driven compilato gerarchico, cioè tale da permettere la suddivisione della rete in moduli, in modo che ogni modulo sia compilato una sola volta, ottenendo così due vantaggi: la riduzione sia della lunghezza del codice che del tempo di preprocessing. Altra caratteristica da non trascurare è la portabilità di questo simulatore su qualsiasi macchina, grazie all’utilizzo di un file che descriva l’architettura della macchina ospite. Questa caratteristica, che non è mai stata menzionata per altri tipi di simulatori, è molto importante nel caso di simulatori compilati, in quanto se questi producessero direttamente codice macchina, rimarrebbero vincolati al processore e al relativo linguaggio.

3.6.1 Logica del Simulatore
Il simulatore descritto è basato su una estensione di un recente simulatore logico chiamato TORTLE. Quest’ultimo simula reti utilizzando un modello logico a 2 stati e 2 forze, cioè una porta può pilotare un nodo con un valore 0/1, o essere in uno stato di alta impedenza.

3.6.2 La Simulazione
Utilizza le due fasi event driven a ritardo 1 mostrate in Fig. 3.16 per ottenene la simulazione di un intervallo temporale.

76

Capitolo 3

La Simulazione di Circuiti Guasti: Stato dell’arte

Fanout: Per ogni nodo nella lista_nodi_attivi { aggiorna valore_nodo con prossimo_valore_nodo aggiungi i fanout del nodo alla lista_porte_attive } azzera la lista_nodi_attivi Simula: Per ogni porta nella lista_porte_attive { Simula porta Per ogni nodo_uscita della porta Se il valore del nodo è cambiato { Salva il nuovo valore in prossimo_valore_nodo Aggiungi il nodo alla lista_nodi_attivi } } Azzera la lista_porte_attive Fig. 3.16: Algoritmo di simulazione base Ci sono 2 fasi etichettate come Fanout e Simula; l’algoritmo utilizza due liste una contenente i nodi attivi e l’altra le porte attive, cioè quelle che necessitano di essere simulate al prossimo istante di tempo. Ad ogni istante, la lista dei nodi viene scandita, ed ogni porta connessa ad ogni nodo attivo viene aggiunta alla lista delle porte attive. Il valore logico di ogni nodo attivo (valore_nodo) viene aggiornato con il valore per il prossimo istante (prossimo_valore_nodo). A questo punto la lista dei nodi attivi può venir cancellata e si può passare alla seconda fase: la lista delle porte attive viene allora scandita, ed ogni porta attiva simulata. L’eventuale variazione del valore di uscita sarà salvato in prossimo_valore_nodo. Simulate tutte le porte attive, la corrispondente lista sarà azzerata per il prossimo istante di tempo. Ognuna delle due liste descritte (che sono di tipo LIFO) è rappresentata da 2 vettori flag e oggetto e da un contatore n. In Fig. 3.17 viene mostrata la procedura di inserzione di un elemento. Questa, in pratica, controlla se l’oggetto è già presente nella lista, aggiungendolo se il test da esito negativo e settando il flag per i futuri controlli.

77

Capitolo 3

La Simulazione di Circuiti Guasti: Stato dell’arte

Se flag[x] = falso allora { flag[x] = vero oggetto[n] = x incrementa n } Fig. 3.17

3.6.3 Estensione alla simulazione compilata
Il primo passo nella trasformazione dell’algoritmo di Fig. 3.16 in una implementazione compilata è generare una procedura personalizzata per le operazioni di Fanout associate ad ogni nodo e per le operazioni di Simulazione associate ad ogni porta. Le liste dei nodi attivi e delle porte attive in questo caso conterranno gli indirizzi delle procedure che necessitano di essere chiamate dallo schedulatore centrale. Il tempo impiegato dallo schedulatore stesso e dalle chiamate alle procedure è considerevole, ma può venire eliminato usando una tecnica inventata per l’implementazione di linguaggi di programmazione; in pratica un ritorno da una chiamata può essere sostituito da un salto alla prossima procedura da eseguire, sviluppando i cicli dello schedulatore centrale. Anche il controllo di fine ciclo può essere eliminato aggiungendo l’indirizzo di uno speciale frammento di codice etichettato “fine della lista”. TORTLE_C è stato dapprima sviluppato in linguaggio C; tuttavia tale linguaggio richiede che la destinazione di una istruzione “goto” sia una etichetta e non permette espressioni per ottenere l’indirizzo di questa. Assumendo di estendere il C in modo che esso ammetta il “goto” indiretto, il simulatore diventa molto efficiente.

3.6.4 Simulazione Gerarchica
Confida sul fatto che molte reti sono scomponibili in un numero di sottocircuiti uguali (come sommatori, multiplatori, contatori ed altro). La struttura di un dato sottocircuito viene chiamata modulo. Ogni modulo diverso può così venire compilato separatamente e, una volta definito, possono essere create copie multiple della circuiteria descritta da quel modulo, chiamate istanze, come

78

Capitolo 3

La Simulazione di Circuiti Guasti: Stato dell’arte

mostrato in Fig. 3.18. Definiamo superistanza, l’istanza che ne contiene altre chiamate a loro volta sottoistanze. Se un modulo viene cambiato è sufficiente ricompilarlo, sempre se viene rispettata l’interfaccia esterna. Sebbene da una parte la simulazione gerarchica offra un miglior comportamento dal punto di vista del preprocessing e della lunghezza del codice prodotto, dall’altra, la gestione della struttura gerarchica si traduce in una riduzione della velocità. Ci aspettiamo così che una rete con alto grado di gerarchia generi un codice molto ridotto e sia più lenta di una con basso grado di gerarchia. TORTLE_C include meccanismi per determinare il grado di gerarchia di un codice generato. Un modulo può venire definito come def o come macro; tra queste descrizioni equivalenti di una stessa struttura di rete, sta nel fatto che le def sono compilate indipendentemente, mentre le macro sono “espanse” direttamente nei moduli che le richiamano, in analogia con il linguaggio C.

Descrizione della rete senza uso di moduli

Istanza del Modulo A

Istanza del Modulo A

Istanza del Modulo B

Istanza del Modulo B

Circuito

Modulo A

Modulo B

Descrizione della rete con uso di moduli

Fig. 3.18 Diverse complicazione sorgono dall’uso della gerarchia. La prima difficoltà è che possono esserci molte istanze per uno stesso modulo. Alla procedura che descrive un modulo deve essere passato come parametro lo stato associato ad una data istanza del modulo. I nodi interni ad un modulo possono essere memorizzati

79

Capitolo 3

La Simulazione di Circuiti Guasti: Stato dell’arte

in una zona di memoria fissata, mentre i nodi che hanno connessioni all’esterno del modulo richiedono alcuni speciali trattamenti. Per questa ragione i nodi di un modulo saranno classificati come nodi e nodi di I/O (Input/Output ), e questi ultimi necessitano dell’indirizzamento indiretto e sono trattati differentemente a seconda che siano utilizzati come ingresso, uscita o entrambe le cose. Per ogni modulo viene generata, esattamente come per le porte, una procedura di Fanout e una di Simulazione; queste saranno responsabili di mantenere l’interfaccia tra un’istanza e la sua superistanza. Una considerazione deve essere fatta a proposito dello schedulatore di istanze per la fase di simulazione e per la fase di diramazione. Un’istanza di un modulo potrebbe non generare eventi sui suoi nodi di I/O, oppure potrebbe esserci qualche attività interna che richiede ulteriori propagazioni al successivo intervallo temporale. Così è importante simulare una istanza ogni volta che potrebbe esserci qualche attività in essa, ma è anche importante evitare di simulare moduli che non hanno attività interna. Per questo ogni procedura ritorna flag che indicano se c’è una attività pendente. Un altro problema sorge quando si passano eventi dall’esterno all’interno del modulo o viceversa. Dal punto di vista gerarchico un modulo viene considerato al pari di una porta, tuttavia sarebbe inefficiente simulare tutte le porte all’interno del modulo ogni volta che un evento si presenta ai suoi ingressi. Per questa ragione è ancora utilizzata una tecnica Event Driven all’interno del modulo; sarà quindi sufficiente fornire la lista degli eventi presenti sui nodi di I/O alla procedura di Fanout. Analogamente, la procedura di Simulazione di un modulo produrrà una lista dei nodi di I/O con attività durante il corrente intervallo di tempo.

3.6.5 Simulazione dei moduli
TORTLE_C usa una struttura chiamata inst per rappresentare ogni istanza di un modulo descritta in Fig. 3.19 mentre in Fig. 3.20 viene presentato l’algoritmo per la simulazione gerarchica dei moduli.

80

Capitolo 3

La Simulazione di Circuiti Guasti: Stato dell’arte

ingressi_attivi nodi_attivi valore_nodo

lista dei nodi di I/O che sono cambiati nell’ultimo intervallo di tempo lista dei nodi (interni) che sono cambiati nell’ultimo intervallo di tempo Valore logico dei nodi (interni)

valore_prossimo_nodo Valore logico dei nodi per il prossimo intervallo di tempo valore_nodo_I/O porte_attive Puntatore ai valori logici dei nodi di I/O lista delle porte che necessitano di essere simulate

sottoinst_fanout_attivo lista delle sottoistanze con nodi (interni) o I/O nodi attivi sottoinst_sim_attiva valore_uscita modo_uscita uscita_attiva sottoistanze lista delle sottoistanze che necessitano della fase di simulazione Valori logici generati come uscita da questa istanza Lista delle uscite di questa istanza che presentano alta impedenza Lista dei nodi di uscita che sono cambiati nell’intervallo temporale corrente Vettore di strutture inst per tutte le sottoistanze di questa istanza. Fig. 3.19: Struttura inst

81

Capitolo 3

La Simulazione di Circuiti Guasti: Stato dell’arte

fanout_modulo: Per ogni nodo nella lista nodi_attivi Per ogni diramazione del nodo Se la diramazione è connessa ad una sottoistanza { Aggiungi nodo alla lista ingressi_attivi per la sottoistanza Aggiungi la sottoistanza alla lista sottoinst_fanout_attivi } altrimenti Aggiungi il fanout alla lista porte_attive ....codice simile per la lista degli ingressi attivi Per ogni modulo nella lista sottoinst_fanout_attivi { Chiama la procedura di fanout per quella sottoistanza Aggiungi la sottoistanza alla lista sottoinst_sim_attive } Simula_modulo: Per ogni porta nella lista porte_attive { Simula la porta Per ogni nodo di uscita della porta Se il valore logico dell’uscita è cambiato Se il nodo è un nodo di I/O Aggiungi il nodo alla lista uscite_attive Altrimenti Aggiungi il nodo alla lista nodi_attivi } Per ogni sottoistanza nella lista sottoinst_sim_attive { chiama la procedura per simulare quella sottoistanza Se il flag di attività ritorna dalla procedura è vero aggiungi la sottoistanza alla lista sottoinst_fanout_attivi Per ogni nodo nella lista uscite_attive della sottoistanza Se il nodo e un nodo di I/O { Aggiorna valore_uscita del nodo Aggiunge il nodo alla lista uscita_attiva di questa istanza } Altrimenti } Aggiorna il valore del nodo Aggiungi il nodo alla lista nodi_attivi } }

82

Capitolo 3

La Simulazione di Circuiti Guasti: Stato dell’arte

Fig. 3.20: Algoritmo per la simulazione gerarchica La procedura di Fanout schedula la simulazione di ogni sottoistanza che potrebbe essere affetta da un cambiamento su di un nodo e richiama una procedura di Fanout per tutte le sottoistanze attive. La procedura di Simulazione simula tutte le sottoistanze attive e aggiorna ogni nodo che è cambiato a causa dell’attività di un modulo. Ogni procedura di simulazione produce anche una lista si attività sui suoi nodi di I/O, la quale viene passata alla sua superistanza, inoltre usa la lista dei nodi I/O ritornata dalle sue sottoistanze allo scopo di aggiornare gli insiemi di nodi, interni e di I/O, attivi. Verrà inoltre ritornato un flag indicante se saranno necessarie elaborazioni successive all’interno del modulo per i prossimo intervallo di tempo (attività pendente del modulo). Questo algoritmo viene facilmente esteso alla simulazione compilata tramite la stessa metodologia vista nel caso della simulazione non gerarchica.

3.6.6 Ottimizzazioni del codice compilato
L’efficienza del codice può essere migliorata con l’applicazione di alcune ottimizzazioni. La prima riguarda le operazioni sulle liste. Ad ogni lista viene associato un vettore booleano per evitare inserzioni multiple di uno stesso elemento. Se è possibile una sola inserzione nella lista, come nel caso di descrittori con un solo ingresso (NOT, FF, BUF), il controllo può essere eliminato dalle relative procedure. Una seconda ottimizzazione è relativa alla rappresentazione di inst. Mentre la struttura dati descritta in Fig. 3.19 è concettualmente pulita, è difficile accedere velocemente a tutte le informazioni presenti. L’inefficienza insorge dal fatto che inst ha 30 campi separati. Tutti questi campi sono vettori, e il codice generato accede ai vari elementi con indici costanti. Il problema è che i microprocessori comuni non hanno un numero sufficiente di registri per contenere gli indirizzi base (base addresses) dei vettori. Per ridurre il numero di riferimenti in memoria, il contenuto di inst è stato linearizzato, così che tutti i dati sono posti in un singolo vettore, con tutti i campi disposti consecutivamente in memoria. Un elemento in un campo può essere indirizzato utilizzando un solo indirizzo base e scegliendo un appropriato offset per l’elemento desiderato.

83

Capitolo 3

La Simulazione di Circuiti Guasti: Stato dell’arte

3.6.7 Implementazione e portabilità
Finora sono state realizzate due versioni di TORTLE_C. La prima implementazione ha come scopo primario la semplicità, per questa ragione si è scelto che il simulatore generasse codice in linguaggio C. Questa scelta riduce leggeremente le prestazioni, sia perché il codice prodotto deve poi essere compilato per produrre una versione eseguibile, sia a causa delle restrizioni imposte dalla sintassi del C all’istruzione “goto”, come discusso al paragrafo 3.4.3; d’altro canto il codice C ha il considerevole vantaggio di essere completamente indipendente dalla macchina su cui viene fatto girare. Questa versione del simulatore utilizza il costrutto “switch” per simulare le istruzioni di salto calcolato, come mostrato in Fig. 3.21.

: : schedulatore_fanout:

schedulatore_simula:

switch(*lista_nodi_attivi++) { fanout_1:............ goto schedulatore_fanout; fanout_2:............ goto schedulatore_fanout; : fine_lista_fanout: break; } switch(*lista_porte_attive++) { simula_1:............ goto schedulatore_simula; simula_2:............ goto schedulatore_simula; : fine_lista_simula: break; }

Fig. 3.21: uso dello “switch” per eliminare le chiamate a procedure TORTLE_C legge la descrizione della rete o di un modulo da un file con estensione net e produce tre file: file con estensioni c, sym e int, che rispettivamente contengono le procedure relative al circuito, la symbol table e l’interfaccia esterna del modulo.

84

Capitolo 3

La Simulazione di Circuiti Guasti: Stato dell’arte

Nel tentativo di migliorare ulteriormente le prestazioni di TORTLE_C, si è realizzata una seconda versione, che produce direttamente codice macchina, superando così le limitazioni del C e riducendo considerevolmente il tempo di preprocessing, non essendo più necessaria la fase di compilazione. La portabilità però era troppo importante per essere abbandonata, per cui molti sforzi sono stati spesi in questa direzione. Per questa ragione sono stati previsti un file, con la descrizione dell’architettura della macchina ospite, e 5 “strati” di software, attraverso i quali il codice deve passare per essere convertito nel linguaggio macchina opportuno. 1 Generazione del codice Viene attraversata la rete generando codice in un linguaggio proprio di una microprocessore ideale (IM Ideal Machine), ortogonale (cioè ogni istruzione può utilizzare ogni tipo di indirizzamento) e capace di arbitrari livelli di indirizzamento di memoria. 2 Selezione del codice Le istruzioni nel linguaggio IM vengono tradotte nelle istruzioni della macchina ospite (TM Target Machine); per far ciò viene utilizzato il file di architettura, che può essere considerato come una specie di dizionario. Ad ogni istruzione IM possono corrispondere una o più istruzioni TM. Potrebbe capitare che TM non ortogonali non abbiano istruzioni che implementano tutte le istruzioni IM; in questo caso vengono applicate regole per scomporre un’istruzione IM in altre più semplici. Questo strato inoltre assume che il processore disponga di un numero infinito di registri interni. 3 Assegnazione dei registri Il codice viene modificato in modo da operare sul numero corretto di registri interni del processore ospite. 4 Riorganizzazione del codice: questo strato è opzionale, risulta lento e inutile su macchine senza “pipeline”. 5 Strato dipendente dalla macchina: Si occupa di scrivere il codice oggetto in un formato appropriato, in relazione sia al tipo di processore che al sistema operativo installato.

85

Capitolo 3

La Simulazione di Circuiti Guasti: Stato dell’arte

La portabilità di TORTLE_C su altre macchine richiede che il programmatore effettui due operazioni: scrivere il file di architettura (cosa che può richiedere meno di un giorno) e riscrivere l’ultimo strato di software , che dipende fortemente dalle caratteristiche hardware della macchina (questo può richiedere più tempo, da uno a tre giorni). Questo tempo viene considerato ragionevole per garantire la portabilità del simulatore.

3.6.8 Limitazioni e possibili estensioni
La limitazione fondamentale di TORTLE_C sta nel modello temporale a ritardo unitario. Risulta complicato estenderlo a trattare ritardi multipli (cioè minimo, massimo, tipico) poiché necessita di strutture più complesse che potrebbero ridurne l’efficienza. La scelta del modello logico non appare invece vincolante per le tecniche descritte, in quanto estendere TORTLE_C a trattare modelli logici più complessi è molto semplice.

3.6.9 Scheda riassuntiva di TORTLE_C
Nome: TORTLE_C Autori: David M. Lewis Logica: 01Z Modello circuitale: Ritardo: Modello a ritardo unitario
COMBINATORIO SEQUENZIALE
NO SI

Riferimento:

[Lewi91]

PORTE CLASSICHE ALTRO

Moduli

Simulazione guasti:
Implementazione: Tecniche adottate: Idee innovative:

STUCK_AT ALTRO FAULT DROPPING

INTERPRETATA COMPILATA PARALLELA

Ripristino Good:

Non specificata

Event Driven, Simulazione compilata ED applicata alla simulazione compilata Simulazione Gerarchica Portabilità del simulatore in codice macchina

86

Capitolo 4 Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti
4.1 Introduzione

Dopo aver discusso le tecniche più diffuse applicate nella fault simulation e aver analizzato alcuni tra i più efficienti simulatori proposti da vari ricercatori, riportiamo in questo capitolo la nostra esperienza, che si basa in parte su tecniche già descritte e in parte su miglioramenti, soprattutto dal punto di vista software, che abbiamo ritenuto bene adottare per velocizzare la simulazione. In particolare si è mirato a realizzare un simulatore parallelo Event Driven e compilato, cercando di mettere insieme alcune idee innovative sviluppate in PROOFS e TORTLE_C. Le tecniche sperimentate sono state implementate, nel limite del possibile, una alla volta, in modo che ogni simulatore realizzato fosse direttamente confrontabile con il precedente per analizzare l’efficacia della modifica introdotta. Nella presentazione di un nuovo simulatore, tutte le caratteristiche che non sono esplicitamente menzionate si ritengono ereditate dalla versione precedente. Sostanzialmente si è cercato di riunire i pregi conservando comunque una linea di simulazione elastica su cui fosse possibile intervenire senza modificare troppo il codice per inserire nuove tecniche. Il capitolo verrà organizzato come segue:

87

Capitolo 4

Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti

• Simulatore sequenziale base • Simulatore parallelo per sequenziali • Simulatore compilato I parametri utilizzati per il confronto fra i diversi simulatori, sono sostanzialmente due: • il tempo di CPU della simulazione campionato prima e dopo il ciclo di simulazione (cioè escludendo le fasi di inizializzazione delle strutture); • il numero di eventi definito come numero totale di variazioni del valore logico sulle porte. I programmi sono stati sviluppati in linguaggio ANSI C su sistema Digital VAX 9000 sotto sistema operativo VMS 5.5. Tutti i risultati sperimentali ottenuti sono riferiti ai circuiti ISCAS 89.

4.2

Simulatore sequenziale SEQSIM

4.2.1 Algoritmo di simulazione
Questo simulatore si basa sul più semplice algoritmo di simulazione sequenziale Event Driven, in riferimento a quanto visto nel secondo capitolo. Costituisce pertanto la struttura base su cui sono state sperimentate via via le varie tecniche. L’algoritmo è descritto in Fig. 4.1.

4.2.2 Simulazione ED
Nel caso della macchina buona si opera su un vettore contente i valori buoni dei nodi denominato gval che viene inizializzato a X prima di incominciare la simulazione del primo vettore di ingresso. Nel caso della macchina guasta si lavora su un vettore contenente i valori guasti denominato fval che viene inizializzato duplicando gval prima di iniettare ogni guasto.

88

Capitolo 4

Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti

Occorre distinguere due fasi di simulazione ED: nella prima sono propagati gli effetti dello stato relativo al guasto considerato creando così un substrato sul quale verrà iniettato il guasto, nella seconda viene propagato l’effetto del guasto. Per effettuare la simulazione ED si definiscono due funzioni denominate prop e get_descr che gestiscono una struttura di propagazione. Prop opera inserendo nella struttura tutti i discendenti della porta passata come parametro, get_descr ritorna la prima porta nella lista di propagazione avente il livello più basso, aggiorna la struttura e segnala quando la lista è vuota. In Fig. 4.2 mostriamo l’algoritmo di simulazione ED.

Legge da un file la descrizione del circuito e la carica in una struttura interna Legge da un file la fault list e la carica in una struttura interna Legge da un file i vettori e li carica in una struttura interna Resetta i FF Per ogni pattern i letto dal file { Applica il pattern i Applica i FF relativi alla macchina buona Simulazione ED Memorizza i FF Per ogni guasto j { Ripristina la macchina buona Applica i FF relativi alla macchina con il guasto j Simulazione ED Iniezione guasto j e simulazione ED Memorizzazione FF relativi alla macchina con il guasto j Controllo rivelazione guasto j } } Fig. 4.1: Algoritmo di SEQSIM

89

Capitolo 4

Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti

porta_corrente = get_descr() Finché( la lista non è vuota) { nuovo_valore = valutazione del nodo di uscita della porta_corrente Se nuovo_valore _ valore_nodo { valore_nodo = nuovo_valore prop (porta_corrente) } porta_corrente = get_descr() } Fig. 4.2: Algoritmo Event Driven

4.2.3 Struttura di propagazione
È costituita da 3 vettori e dimensionati come segue (Fig. 4.3): • head Ha un numero di elementi pari al massimo livello presente nel circuito e contiene la prima porta da simulare per ogni livello. • next Ha dimensione pari al numero di elementi della struttura del circuito, contiene le restanti porte da simulare per ogni livello. • present È un vettore booleano che può assumere il valore PRESENT o ABSENT, della stessa dimensione di next; contiene l’informazione relativa alla presenza o meno di un elemento nella lista. I tre vettori sono inizializzati prima di applicare il primo vettore di ingresso, gli elementi di head e next sono posti ad un valore negativo, codificato con FINE, per rappresentare che la lista è vuota; gli elementi di present sono posti al valore ABSENT.

90

Capitolo 4

Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti

head
1 2

next
1 2

present
1 2 3 4 5 6 7 8 9 10
PRESENT

Livelli
1

1 2 6

4 5 7 8 9 10

PRESENT
ABSENT

1 4 7 9 10 2 5 8 NULL 6 NULL

3 FINE 4

3 FINE 4 5

2 3 4 5

PRESENT PRESENT PRESENT PRESENT PRESENT PRESENT PRESENT

5 FINE

6 FINE 7

8 FINE 9

10 FINE

(a) Implementazione con 3 vettori

(b) Implementazione classica

Fig. 4.3: Struttura di propagazione La lista di propagazione, realizzata in questo modo, permette di usare solo tre vettori indipendentemente dal numero di livelli del circuito, per contro la procedura di accesso ai singoli elementi della lista risulta abbastanza complessa.

4.2.4 Valutazione dei descrittori
La procedura eval si occupa della valutazione delle porte, accetta come parametri il numero identificativo della porta e la lista dei nodi su cui deve lavorare (gval o fval). Si cerca il valore forzante sugli ingressi come già descritto nel paragrafo 2.4.4; gli EXOR e gli EXNOR vengono valutati con l’ipotesi di soli due ingressi e, nel caso questi fossero in numero maggiore si opera considerando un numero di porte (a due ingressi) in cascata pari a N-1, indicando con N il numero totale degli ingressi della porta. Quanto descritto per la valutazione delle porte non è vincolante per la simulazione, in quanto altre tecniche possono essere utilizzate con prestazioni comparabili.

4.2.5 Iniezione dei guasti
La procedura di simulazione della macchina guasta fsim comprende l’iniezione del guasto il cui numero di identificazione viene passato come parametro.

91

Capitolo 4

Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti

Possono essere considerati sia guasti stuck-output che stuck-input secondo l’algoritmo già visto nel paragrafo 2.5.1. L’iniezione è realizzata andando a modificare il valore del nodo considerato nel vettore fval; a ciò segue la propagazione degli effetti.

4.2.6 Memorizzazione degli stati dei flip flop
I valori dei flip flop sono immagazzinati in due strutture distinte: ff_good_value e ff_faulty_value. La prima contiene i valori dei flip flop della macchina buona dopo l’applicazione di ogni vettore di ingresso, la seconda è bi-dimensionale (n_ff n_guasti) e contiene i valori dei flip flop dopo la propagazione di ogni guasto. Le strutture sono dimensionate in base al numero di flip flop che vengono tutti registrati prescindendo dal fatto che alcuni non sono variati, con conseguente spreco di memoria.

4.2.7 Applicazione dei vettori di ingresso e dei flip flop
Queste due operazioni avvengono in maniera analoga; di fatto si inseriscono, nei nodi corrispondenti ai PI e ai PPI, i valori dei vettori di ingresso e dei flip flop immagazzinati nelle relative strutture interne. Se un nodo subisce una variazione allora viene chiamata la procedura prop.

4.2.8 Rivelazione guasti e fault dropping
Quando almeno un’uscita primaria della macchina guasta ha valore logico opposto alla corrispondente uscita della macchina buona, allora il guasto è rivelato. Un vettore booleano di dimensione n_guasti, che può assumere i valori YES o NO, viene utilizzato per registrare la rivelazione; in questo modo il guasto, se rivelato, non verrà più preso successivamente in considerazione.

92

Capitolo 4

Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti

4.2.9 Risultati sperimentali
Riportiamo i risultati ottenuti con SEQSIM sui circuiti di prova con i vettori d’ingresso generati da un ATPG.

ISCAS 89
s208 s298 s344 s349 s382 s386 s400 s420 s444 s510 s526 s526n s641 s713 s820 s832 s838 s953 s1196 s1238 s1423 s1488 s1494 s5378 s9234

n° vettori
218 354 147 243 353 402 388 142 167 1000 296 296 351 600 1005 1026 198 438 322 315 139 1097 1354 188 400

n° guasti
232 274 370 372 366 346 374 464 412 474 436 438 868 896 626 622 916 882 1124 1082 1498 1336 1324 5988 6836

cop. %
76,724 94,161 97,297 97,312 93,443 97,399 91,711 56,034 90,534 99,578 66,055 66,210 83,871 88,393 97,604 97,428 43,668 94,218 99,822 97,412 49,399 98,129 99,547 69,923 15,506

Tempo Tempo sim. guasta totale [s] [s]
1,34 1,12 0,79 1,25 6,8 2,28 9,35 4,85 8,11 2,33 10,84 10,42 16,35 27,26 10,63 26,22 31,2 12,96 13,23 16,02 60,23 31,64 21,32 556,99 5779,57 1,41 1,24 0,83 1,32 6,92 2,42 10,26 4,89 8,17 2,88 10,96 10,56 16,55 27,62 11,45 26,31 31,32 13,32 13,66 16,7 60,63 34,59 25,04 557,95 5780,68

Fig. 4.4: Tabella SEQSIM

93

Capitolo 4

Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti

4.3

Simulatore parallelo per circuiti sequenziali

4.3.1 PARSEQv1
PARSEQv1 discende direttamente da SEQSIM ed è ancora un simulatore ED, ma sfrutta il parallelismo della macchina (32 bit) per ottenere maggiori velocità di elaborazione, come si è già ampiamente osservato nel capitolo 2. Per raggiungere questo scopo occorre cambiare alcune strutture; di seguito illustreremo le modifiche apportate a: • Simulazione di macchina guasta • Iniezione dei guasti • Memorizzazione e applicazione dei flip flop Questo simulatore si adatta anche a macchine con parallelismo diverso da 32 (es. 64 o 16 bit), negli algoritmi presentati ci riferiremo al caso di 32 bit, ma questi rimangono validi anche per gli altri formati.

Simulazione di macchina guasta Prima di effettuare la simulazione ED si costruisce un pacchetto di 32 guasti da simulare in parallelo. Questo viene fatto tramite il vettore inj_fault che si occupa di conservare la corrispondenza tra il numero del guasto e la sua posizione nel pacchetto. Successivamente si procede alla fase 1, cioè alla propagazione fino alle uscite di tutti gli stati memorizzati nei flip flop e associati ai 32 guasti, in modo da creare il substrato necessario alla iniezione del pacchetto. Ogni guasto viene quindi iniettato tramite mascheramento singolo e modifica del tipo del descrittore da “type” a F_type”, come visto nel paragrafo 2.5.1, ma ora in più è richiesto di poter operare sul singolo bit di ogni elemento del vettore che descrive un nodo del circuito. A questo scopo utilizziamo una maschera di dimensione pari alla parola di memoria del calcolatore e inizializzata in modo che l’LSB sia l’unico bit al valore logico 1. All’iniezione di ciascun guasto segue lo scorrimento verso sinistra della maschera che così si predispone per il guasto successivo. I guasti stuck-input sono difficili da manipolare con la tecnica descritta, poiché

94

Capitolo 4

Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti

sarebbero necessarie altre maschere, e precisamente una per ogni nodo di ingresso di ciascuna porta. Per questa ragione, d’ora in avanti, considereremo solo guasti stuck-output, scelta giustificata dal fatto che la copertura di tutti questi garantisce comunque una buona copertura dei guasti stuck-input. Una volta terminata l’iniezione, si procede alla simulazione ED (fase 2) allo scopo di propagare gli effetti del pacchetto dei guasti e determinarne l’eventuale rivelazione. In Fig. 4.5 presentiamo il relativo algoritmo. Iniezione dei guasti L’iniezione dei guasti (solo stuck-output, come è già stato detto) merita un riguardo particolare. Essenzialmente esistono due situazioni: • Il guasto è posto su un descrittore a livello 0, cioè un ingresso primario o un flip flop. In questo caso può essere inserito fisicamente, invertendo il bit corrispondente nel nodo, in quanto la propagazione incomincia dal livello 1. • Il guasto è posto su un descrittore a livello superiore: va quindi inserito tramite mascheramento. Le maschere sono conservate in un vettore denominato inj_val di dimensione pari al numero di descrittori. All’operazione di memorizzazione (in inj_val) della maschera deve seguire la modifica del tipo del descrittore da ”type “ a “F_type”. Il tipo di un descrittore è codificato con un numero; aggiungendo un valore OFFSET (maggiore del numero di tipi logici presenti nel circuito) si determina il nuovo tipo. Bisogna però stare attenti che un guasto viene inserito nel pacchetto può eccitare il sito, oppure lo stato dei flip flop (ottenuto con l’applicazione del vettore d’ingresso precedente) associato a quel guasto generare eventi; possono quindi essere presenti entrambi i guasti stuck-at-0 e stuck-at-1 su uno stesso descrittore, e pertanto questi non sono mutuamente esclusivi, come erroneamente si potrebbe pensare. Per tener conto di questo problema non bisogna aggiungere un ulteriore OFFSET, ma variare la maschera del descrittore inserendo un altro 1 in corrispondenza del nuovo guasto.

95

Capitolo 4

Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti

Finché ci sono guasti i da simulare { numero_bit = 0 maschera = 1 Costruzione pacchetto di 32 guasti: Finché numero_bit < 32 ed i < n_fault { Se il guasto i non è già stato rivelato { Applica i FF relativi al guasto i Se lo stato genera eventi oppure il guasto è eccitato allora { inj_fault [numero_bit] = i shift a sinistra della maschera di un bit } } incrementa i } Fase 1, propagazione dei FF: livello_corrente = 0 Simulazione ED Iniezione dei 32 guasti: livello_corrente = massimo livello (Inizializza per la prossima iniezione) Per ogni bit 0 < bit < 32 Inietta il guasto inj_fault[bit] (procedura iniezione guasti) Fase 2, propagazione effetti dei 32 guasti: Simulazione ED Controllo rivelazione guasti e relativa fault dropping Memorizzazione dello stato dei FF relativi ai 32 guasti Recupero dello stato della macchina buona De-iniezione dei 32 guasti } Fig. 4.5: Algoritmo PARSEQv1 Durante la simulazione di macchina guasta i valori dei nodi vengono salvati in uno stack prima di venire modificati. Al termine della simulazione di un pacchetto è necessario ripristinare il circuito nelle condizioni originarie, cioè riportare i valori dei nodi a quelli della macchina buona e gli “F_type” a “type” (operazione di de-iniezione). Gli algoritmi di Fig. 4.6 schematizzano quanto detto.

96

Capitolo 4

Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti

Iniezione del guasto k: ID_porta_guasta = numero della porta su cui è localizzato il guasto k Se porta_guasta è un PI o un FF { Salva il valore del nodo fval[ID_porta_guasta] fval[ID_porta_guasta] = fval[ID_porta_guasta] EXOR maschera prop ID_porta_guasta livello corrente = 1 } Altrimenti { Se descr[ID_porta_guasta].type<OFFSET cambia “type” in “F_type” { inj_val[ID_porta_guasta] = maschera Aggiungi OFFSET a descr[ID_porta_guasta].type } Altrimenti ( è già un F_type) inj_val[ID_porta_guasta] = inj_val[ID_porta_guasta] OR maschera Se il livello della porta < livello_corrente livello_corrente = livello della porta Inserisci direttamente la porta in struttura di propagazione } De-iniezione dei 32 guasti : Per ogni bit<numero di bit { ID_porta_guasta = porta su cui è localizzato il guasto inj_fault[bit] Se descr[ID_porta_guasta].type >= OFFSET Sottrai OFFSET da descr[ID_porta_guasta].type } Fig. 4.6: Algoritmi di iniezione e de-iniezione Memorizzazione e applicazione dei flip flop Al termine della simulazione di un pacchetto, i nodi di ingresso dei flip flop, conterranno i 32 stati futuri relativi ai guasti appena considerati. Se questi fossero presi sequenzialmente, cioè indipendentemente dalla loro eccitazione o da fault dropping, si potrebbe memorizzare il pacchetto completo in modo da applicarlo assieme al vettore successivo. Si è però scelto di inserire solo i guasti eccitati e non ancora rivelati, e di conseguenza sui nodi dei flip flop si troveranno gli effetti di 32 guasti presi con un ordine casuale. Con il vettore seguente ognuno di questi

97

Capitolo 4

Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti

32 potrebbe essere posto su un pacchetto diverso oppure non essere presente per quel passo di simulazione, perché non eccitato o perché appena rivelato. Per questa ragione occorre separare i 32 stati, in base al numero del guasto associato a ciascuno stato, inserendoli nella apposita struttura di memorizzazione. Questa in linea di principio può essere pensata come una matrice bidimensionale, dove le righe rappresentano i guasti e le colonne i flip flop.

Guasti
1

flip flop

7 10
0 0

ID Valore

PI RETE COMBINATORIA

PO
2 3 4
B 1111

NULL 7 9 10
0 1 0

NULL 7 9
0 1

5

7

G 0010

inj_fault
B 0000

1 3 4 5
9
G 0101 B 1111

10

G 0011

I valori dei flip flop vengono letti bit a bit e inseriti nella struttura di memorizzazione

Fig. 4.7: Applicazione degli stati relativa ai guasti Per ottenere un risparmio in termini di tempo e di memoria è bene memorizzare solo i flip flop cambiati rispetto alla macchina buona. Ovviamente in questo caso occorre memorizzare sia il numero del flip flop che il loro valore. Per quanto riguarda l’applicazione dei flip flop bisogna effettuare l’operazione inversa, cioè prelevare gli stati relativi ai guasti che si vuole considerare e inserirli fisicamente nei bit corrispondenti dei nodi di uscita dei flip flop. La Fig. 4.7 può essere utile a capire il trattamento degli stati guasti.

98

Capitolo 4

Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti

4.3.2 PARSEQv2
Una causa di inefficienza della prima versione di PARSEQ stava nella distinzione tra la fase 1 e la fase 2 in quanto comportava in alcuni casi la duplice valutazione delle porte che potevano trovarsi nella lista di propagazione prima dei flip flop applicati e poi del guasto iniettato; si è pensato allora di unificare le due fasi. A tale scopo occorre intervenire su: • algoritmo di simulazione della macchina guasta; • mascheramento dei guasti; Algoritmo di simulazione Viene modificato in modo da effettuare un’unica fase di simulazione ED dopo aver applicato gli stati dei 32 guasti selezionati e aver iniettato il pacchetto. L’algoritmo di Fig. 4.8 implementa questa idea.

Costruzione pacchetto di 32 guasti e loro iniezione Finché numero_bit < 32 ed i < n_fault { Se il guasto i non è già stato rivelato { Applica i FF relativi al guasto i Se lo stato genera eventi oppure il guasto è eccitato allora { inj_fault [numero_bit] = i inietta il guasto i shift a sinistra della maschera di un bit } } incrementa i } Fase unica di propagazione livello_corrente = 1 Simulazione ED Controllo rivelazione guasti e relativa fault dropping Memorizzazione dello stato dei FF relativi ai 32 guasti Recupero dello stato della macchina buona De-iniezione dei 32 guasti } Fig. 4.8: Algoritmo simulazione macchina guasta per PARSEQv2

99

Capitolo 4

Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti

Iniezione dei guasti In questo caso non è più definito il substrato su cui è iniettato il guasto e possono verificarsi le tre situazioni seguenti:

Fi

Se il cono di propagazione dello stato dei flip flop generato dal guasto Fi al passo precedente non influenza il nodo su cui è localizzato il guasto stesso, possiamo stabilire con sicurezza se Fi è eccitato o meno.

Fi

Se l’applicazione dei flip flop non genera eventi, possiamo stabilire con sicurezza se Fi è eccitato o meno.
Se il cono di propagazione dello stato dei flip flop generato dal guasto Fi al passo precedente influenza il nodo l su cui è localizzato il guasto stesso, non possiamo stabilire a priori se Fi sia eccitato o meno in quanto le fasi 1 e 2 sono contemporanee.

Fi

nodo l

Per quest’ultima ragione non si può usare il mascheramento singolo, che inverte il valore del nodo, operazione che deve comunque avvenire prima della simulazione presupponendo la conoscenza del substrato su cui verrà inserito il guasto. Unificando le due fasi, il substrato del nodo l viene generato appena un momento prima di effettuare il mascheramento, e da qui la necessità di utilizzare maschere che iniettino il guasto a prescindere dal valore del substrato. Verrà quindi utilizzato un mascheramento doppio come descritto nel paragrafo 2.5.1. Il test di candidatura di un guasto per essere inserito in un pacchetto è riportato in Fig. 4.9.

Applicazione dei FF relativi al guasto Fi Se i FF generano eventi oppure Fi è eccitato rispetto alla macchina buona allora Il guasto Fi è candidato a essere inserito nel pacchetto Fig. 4.9: Test di candidatura di un guasto

100

Capitolo 4

Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti

4.3.3 Risultati sperimentali
Riportiamo di seguito in Fig. 4.10 la tabella che confronta in termini di numero di eventi le due versioni presentate di PARSEQ. Riduzioni considerevoli, si possono notare con la versione 2 (su alcuni circuiti anche del 15%). Indicheremo con “%” la variazione percentuale del numero di eventi tra le due versioni. Nelle tabelle che presentiamo usereremo per brevità le notazioni MB ed MG per indicare rispettivamente la Macchina Buona e quella Guasta.

PARSEQv1 ISCAS 89 vettori di ingress o
218 354 147 243 353 402 388 142 167 296 351 600 1005 1026 198 322 315 139 1097 1353 188

PARSEQv2 eventi fase unica.
11500 8806 7758 7827 83948 20203 122036 30130 105034 103409 29288 68024 62904 73299 107045 53859 67032 223199 96232 75640 452940

eventi M.B.

eventi fase1

eventi fase2

eventi totali

eventi totali

%

S208 S298 S344 S349 S382 S386 S400 S420 S444 S526 S641 S713 S820 S832 S838 S1196 S1238 S1423 S1488 S1494 S5378

5445 9158 7371 9907 11043 15880 11286 3716 5925 9008 22614 39651 67909 68724 9429 48291 42488 30143 246096 301880 114245

2475 3155 3072 2762 65819 3076 94241 7314 84929 68879 3319 12737 12036 14440 25658 3634 3708 120005 21766 25517 103407

10152 6438 5322 6074 30006 18321 51476 25986 31260 44227 26506 57862 53066 62276 91382 50608 63623 131350 77448 53542 382308

18072 18751 15765 18743 106868 37277 157003 37016 122114 122114 52439 110250 133011 145440 126469 102533 109819 281498 345310 380939 599960

16945 17964 15129 17734 94991 36083 133322 33846 110959 112417 51902 107675 130813 142023 116474 102150 109520 253342 342328 377520 567185

6,24 4,20 4,03 5,38 11,11 3,20 15,08 8,56 9,13 7,94 1,02 2,34 1,65 2,35 7,90 0,37 0,27 10,00 0,86 0,90 5,46

Fig. 4.10: Tabella di confronto eventi

101

Capitolo 4

Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti

Passiamo ora a confrontare, nella tabella di Fig. 4.11, i tempi di SEQSIM con PARSEQv2 per quantificare il vantaggio derivato dall’applicazione del parallelismo di macchina. Indicheremo con lo speed up tra i simulatori cioè il rapporto tra i tempi ottenuti con le diverse simulazioni.

SEQSIM

PARSEQv2

ISCAS Pattern Tempo Tempo Tempo Tempo M.G. totale M.G. totale [s] [s] [s] [s]
s208 s298 s344 s349 s382 s386 s400 s420 s444 s510 s526 s526n s641 s713 s820 s832 s838 s953 s1196 s1238 s1423 s1488 s1494 218 354 147 243 353 402 388 142 167 1000 296 296 351 600 1005 1026 198 438 322 315 139 1097 1354 1,34 1,12 0,79 1,25 6,8 2,28 9,35 4,85 8,11 2,33 10,84 10,42 16,35 27,26 10,63 26,22 31,2 13,24 13,23 16,02 60,23 31,64 21,32 1,41 1,24 0,83 1,32 6,92 2,42 10,26 4,89 8,17 2,88 10,96 10,56 16,55 27,62 11,45 26,31 31,32 13,82 13,66 16,7 60,63 34,59 25,04 0,12 0,16 0,09 0,13 0,78 0,26 1,14 0,38 0,9 0,98 1,09 1,23 0,57 1,02 0,88 1,19 1,29 1,41 0,42 0,82 2,52 1,81 1,79 0,18 0,25 0,17 0,22 0,86 0,36 1,24 0,4 0,92 1,4 1,14 1,46 0,78 1,36 1,36 1,6 1,67 1,22 1,09 1,22 2,72 3,76 4,36 7,83 4,96 4,88 6,00 8,05 6,72 8,27 12,23 8,88 2,06 9,61 7,23 21,22 20,31 8,42 16,44 18,75 11,33 12,53 13,69 22,29 9,20 5,74

Fig. 4.11: Tabella di confronto tempi

102

Capitolo 4

Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti

4.4

Simulatore parallelo sequenziale compilato

In questa sezione verranno presentate 4 versioni del simulatore PARSEC, ognuna con le proprie caratteristiche, e verrà descritto il programma COMP che si occupa di trasformare la descrizione del circuito in codice macchina.

4.4.1 PARSECv1
Con questo simulatore si è cercato di implementare direttamente sull’ossatura di PARSEQ la simulazione compilata, senza preoccuparsi, in un primo momento, di cercare soluzioni che ne aumentino l’efficienza, ma piuttosto di realizzare un algoritmo di base semplice su cui lavorare in seguito. L’idea che lo contraddistingue dal suo predecessore sta nelle procedure di valutazione (eval) e propagazione (prop) delle porte. Finora due sole procedure erano utilizzate a tale scopo: queste accettavano come parametro il descrittore su cui operare ed erano del tutto generali, e pertanto in grado di poter trattare qualsiasi configurazione topologica. In PARSECv1 le procedure eval e prop vengono generate “ad hoc” per ogni descrittore da un opportuno programma esterno denominato COMP. Per l’iniezione dei guasti viene usata una strategia leggermente diversa da PARSEQ. Un vettore booleano is_faulty[] si occupa di specificare se la porta è affetta da guasto; a seconda del suo valore, una procedura eval calcola solo il valore di uscita o effettua anche il mascheramento doppio. La simulazione di un circuito ora richiede più passi rispetto a prima a causa della generazione, compilazione e link delle procedure che lo descrivono, come mostrato in Fig. 4.12

103

Capitolo 4

Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti

COMP

Modello Circuitale
{ { {

}

}

}

Modulo1.c

Modulo2.c

Modulo3.c

Compilatore

MOV A CLI XOR C JMP 33

MOV A CLI XOR C JMP 33

MOV A CLI XOR C JMP 33

Modulo1.obj

Modulo2.obj

Modulo3.obj

MOV A CLI XOR C JMP 33

LINK

PARSEC.obj

10110 01010 11101 Vettori di Ingresso

PARSEC .EXE

n. 12 n. 21 n. 33 Guasti non rivelati

n. 1 n. 2 n. 3 Lista dei Guasti

Fig. 4.12: Schema della simulazione compilata

Si è scelto di generare le procedure in linguaggio C per garantire la portabilità del simulatore su qualsiasi calcolatore. Questo comporta la successiva compilazione del codice prodotto con un aumento dei tempi di preprocessing.

104

Capitolo 4

Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti

In linea di principio un solo modulo, contenente tutte le procedure generate, sarebbe sufficiente, ma con circuiti di dimensioni medio-grandi il numero di procedure fa superare il limite massimo di simboli ammesso dal compilatore (dimensioni della symbol table). Per ovviare a questo inconveniente si è pensato di smistare le procedure su diversi moduli, in modo che sia rispettato il numero massimo di procedure accettate dal compilatore. Tutte le volte che un programma viene diviso in moduli compilati separatamente, nasce un problema di visibilità dei simboli. Questo problema è stato risolto come segue: in ogni modulo i è prevista una funzione read_address_i che copia tutti gli indirizzi delle procedure definite in quel modulo nei vettori eval[] e prop[]. Una funzione read_address_all, contenuta in un ultimo modulo, provvederà a richiamare, una alla volta, le procedure read_address_i., come mostrato in Fig. 4.13.

Modulo 1: Definizione di eval0_ Definizione di prop0_ : Definizione di eval7_ Definizione di prop7_ Definizione di read_address_1: eval[0] = indirizzo di eval0 prop[0] = indirizzo di prop0 : eval[7] = indirizzo di eval7 prop[7] = indirizzo di prop7

Modulo 2: Definizione di eval8_ Definizione di prop8_ : Definizione di eval21_ Definizione di prop21_ Definizione di read_address_2: eval[8] = indirizzo di eval8 prop[8] = indirizzo di eval8 : eval[21] = indirizzo di eval21 prop[21] = indirizzo di prop21

Modulo 3: (Ultimo) Definizione di read_address_all: chiama la procedura read_address_1 chiama la procedura read_address_2 Fig. 4.13: Divisione in moduli

Tutta la fase di preprocessing viene gestita con un programma batch che svolge le seguenti funzioni:

105

Capitolo 4

Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti

1 Richiedere i nomi dei file contenenti: - la descrizione del circuito; - la fault list; - i vettori di ingresso. 2 Richiedere il numero di moduli. 3 Eseguire COMP. 4 Compilare tutti i file con estensione “c” generati. 5 Collegamento (link) degli oggetti creati con il codice oggetto del programma principale e con le librerie C. 6 Esecuzione di PARSEC. Ora illustreremo in maniera dettagliata come COMP genera le procedure di eval, e prop. Ogni porta viene analizzata sulla base dei suoi successori, del tipo e dei nodi di ingresso sui quali è inserita. In Fig. 4.14 sono riportati due esempi di procedure. Al programma principale bisognerà apportare le seguenti modifiche: • richiamare la procedura read_address_all in fase di inizializzazione; • sostituire le chiamate a eval(porta) con *(eval[porta])(), che nella sintassi C significa richiamare la procedura avente indirizzo eval[porta]; • sostituire le chiamate a prop(porta) con *(prop[porta])(); • sostituire l’operazione di modifica da “type” a F_type” o viceversa con l’assegnazione del valore YES o del valore NO al vettore is_faulty[porta_guasta].

106

Capitolo 4

Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti

1 7 9 3

12 8 5

Procedura eval3: Se is_faulty[3] = NO allora nuovo_valore = val[1] AND val[7] AND val[9] Altrimenti nuovo_valore = (val[1] AND val[7] AND val[9]) AND inj0_val[3] OR inj1_val[3] Procedura prop3 Se present[5] = ABSENT allora { present[5] = PRESENT inserisci 5 nella lista di propagazione } Se present[8] = ABSENT allora { present[8] = PRESENT inserisci 8 nella lista di propagazione } Se present[12] = ABSENT allora { present[12] = PRESENT inserisci 12 nella lista di propagazione } Fig. 4.14: Procedure compilate

107

Capitolo 4

Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti

4.4.2 PARSECv2
Per migliorare l’efficienza del simulatore è conveniente riorganizzare alcune parti in modo da trarre i massimi vantaggi dall’uso della tecnica compilata, in particolare sono state modificate: • procedure “ad hoc” • struttura di propagazione • schedulatore centrale Denominatore comune delle innovazioni proposte è la memorizzazione diretta nella struttura di propagazione degli indirizzi delle procedure da richiamare, invece che degli ID delle porte da simulare. Grazie a questo accorgimento è stato possibile dividere, come in PARSEQ, le procedure di valutazione delle porte in due categorie: eval, se la porta non presenta guasti, f_eval, viceversa; questo è l’esatto equivalente compilato di “type” e “F_type”. La fase d’iniezione del guasto consisterà semplicemente nell’inserimento dell’indirizzo della f_eval associata alla porta sorgente di guasto nella lista di propagazione e alla modifica delle due maschere che saranno utilizzate per l’iniezione del guasto in corrispondenza del bit voluto. Procedure “ad hoc” È facile osservare che le procedure di eval e prop sono molto legate, in quanto la propagazione è la diretta conseguenza dell’operazione di valutazione di una porta, qualora il valore determinato è diverso da quello precedente; ci è sembrato pertanto logico riunire queste due in un’unica procedura nei casi siano richiamate in sequenza, se questo non accade come nel caso dei descrittori a livello 0, che richiedono solo la fase di prop, si definisce una eval fittizia che non effettua valutazioni, ma solo propagazione. Sempre seguendo questa filosofia, una volta chiamata la procedura relativa ad un descrittore, è conveniente fare su questo tutte le operazioni necessarie. Alcune elaborazioni compiute su particolari porte (controllo delle uscite sulle PO e memorizzazione stati sui Flip Flop) risultano infatti più efficienti se realizzate “ad hoc”. In Fig. 4.15 riportiamo alcuni esempi delle nuove procedure generate con questi accorgimenti

108

Capitolo 4

Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti

Procedura eval3:

(porta qualsiasi)

Present[3] = ABSENT nuovo_valore = val[1] AND val[7] AND val[9] Se nuovo_valore _ val[3] { Salva il valore di val[3] (per il recupero della macchina buona) val[3] = nuovo_valore (cioè assegna il nuovo valore al nodo di uscita) Se present[5] = ABSENT allora { present[5] = PRESENT inserisci l’indirizzo di eval5 nella lista di propagazione } Se present[8] = ABSENT allora __ Se present[12] = ABSENT allora __ } Procedura eval17: (PO) Procedura eval44: (Padre di FF) Present[44] = ABSENT nuovo_valore = __ Se nuovo_valore _ val[44] { Salva il valore di val[44] val[44]= nuovo_valore Se present[53]= ABSENT allora __ Se effettuo la simulazione buona Memorizza lo stato associato all’ingresso del FF (n.53) Altrimenti Memorizza i 32 stati associati all’ingresso del FF (n.53) variati }

Present[17] = ABSENT nuovo_valore = __ Se nuovo_valore _ val[17] { Salva il valore di val[17] val[17]= nuovo_valore Se present[15] = ABSENT allora __ Se present[23] = ABSENT allora __ Controllo rivelazione dei 32 guasti }

Fig. 4.15: Procedure compilate

109

Capitolo 4

Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti

In relazione alla Fig. 4.15 bisogna notare che può esistere la procedura frutto della combinazione delle ultime due nel caso di un padre di un flip flop che è anche una uscita primaria. In particolare vogliamo mettere in evidenza i seguenti fatti: • Ad ogni eval corrisponde una f_eval, simile in tutto eccetto che nel mascheramento effettuato subito dopo la valutazione dell’espressione logica associata e alla reinizializzazione delle maschere di quella porta una volta adoperate. • Quando viene chiamata una procedura, si provvede come prima cosa a togliere la porta su cui si opera dalla lista di propagazione; è questa infatti la sede più adatta per fare questa operazione evitando indirizzamenti indiretti. • La memorizzazione dei valori degli stati futuri è inserita solo nelle procedure delle porte connesse a un flip flop ed è realizzata su strutture diverse in base al tipo di simulazione buona o guasta. Nel primo caso è sufficiente memorizzare il valore del nodo, nel secondo occorre scandire con una maschera tutti i bit del nodo relativi ai guasti iniettati per vedere se ci sono variazioni rispetto al valore buono in caso positivo il valore è immagazzinato. • Il controllo della rivelazione dei guasti è realizzato sulle porte che sono uscite primarie. Il nodo d’uscita viene scandito bit a bit, ricavando così i valori associati ad ogni guasto che vengono confrontati con il valore della macchina buona. Struttura di propagazione La struttura di propagazione viene modificata per renderla più lineare e di più facile accesso, come visto nel paragrafo 2.8.2, inoltre, come già detto, essa conterrà gli indirizzi della procedura da attivare, una eval se sul descrittore non è sorgente di guasto, una f_eval viceversa. Tutto ciò è reso più funzionale usando puntatori per inserire ed estrarre gli elementi della lista come si può notare in Fig. 4.16.

110

Capitolo 4

Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti

p_des q p

Lev ( * p)

- -( * q)

( * q)

* (- -( * q)) = indirizzo di procedura eval8()

Fig. 4.16: Struttura di propagazione Schedulatore centrale È quella porzione di programma che si occupa di richiamare in ordine le porte, e quindi le procedure associate, che richiedono di essere simulate. Risulta dipendente dalla struttura di propagazione e dal tipo di simulazione (buona o guasta). Riportiamo in Fig. 4.17 il codice in linguaggio C piuttosto che l’algoritmo per mettere in evidenza l’alto grado di efficienza così ottenuto.

#define call (A)

(*(A))() /* richiama la procedura d’indirizzo A */

p = lev; /* inizializzazioni */ q = p_des; while ( p _ p_max ) /* finché non è raggiunto l’ultimo livello */ if ( *p == *q ) /* controllo di fine scansione livello */ p++, q++; /* passa al livello successivo */ else call ( *(--(*q))); /* estrazione e richiamo delle procedure */ Fig. 4.17: Codice C dello schedulatore

111

Capitolo 4

Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti

4.4.3 PARSECv3
Questa versione è caratterizzata da due importanti innovazioni che migliorano il simulatore sia dal punto di vista della memoria richiesta che da quello della velocità di esecuzione: • allocazione dinamica della memoria destinata ai flip flop; • fault dropping ; Allocamento dinamico della memoria destinata ai flip flop Si è già fatto riferimento a questa possibile modifica nel paragrafo 2.9.2, in relazione alla notevole memoria occupata dai flip flop, immagazzinati per tutti i guasti, e al fatto che durante un passo di simulazione solo il 10% circa cambia il suo valore. Abbiamo anche osservato che si possono memorizzare solo quelli variati rispetto alla macchina buona, e questo aumenta l’efficienza del simulatore ma non diminuisce l’occupazione in memoria, poiché occorre preventivare, per ogni guasto, la possibilità che tutti i flip flop possano cambiare riservando quindi uno spazio sufficiente. Per diminuire l’occupazione di memoria si potrebbe sfruttare una serie di funzioni di libreria messe a disposizione dal linguaggio C, che permettono di allocare (malloc) e rilasciare (free) uno spazio in memoria della dimensione desiderata. In questo modo è facile costruire una struttura che si espande e si contrae dinamicamente in base al numero di flip flop attivi, evitando così di dover preimpostare la dimensione di una struttura che non verrà mai riempita completamente. Il problema è che la malloc, per ottenere la memoria necessaria, invoca il sistema operativo con un conseguente rallentamento. La strategia che allora conviene seguire è quella di preventivare uno spazio di memoria pari, ad esempio, al 10% del massimo teorico, e fare su esso operazioni simili, ma molto semplificate, a quelle effettuate da malloc e free sull’intera memoria del calcolatore. In Fig. 4.18 è mostrata la nuova struttura di memorizzazione. Si tratta di un numero di liste linkate pari al numero di guasti che si vuole simulare, ad ogni lista verranno quindi “agganciati” solo i flip flop attivati dal relativo guasto. Con la struttura vista precedentemente, questi erano disposti consecutivamente all’interno di un vettore, mentre adesso sono “sparpagliati” nella lista ff_memo. Il collegamento tra le varie celle è garantito da una catena di puntatori. Un’apposita struttura parallela ff_hole è utilizzata per conservare l’informazione relativa a

112

Capitolo 4

Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti

quali celle sono vuote e quali no. Quando sarà necessario aggiungere un elemento ad una lista, sarà sufficiente inserirlo in una qualunque cella vuota e aggiornare sia la catena dei puntatori che la struttura ff_hole. Queste due ultime operazioni saranno poi necessarie per effettuare l’operazione inversa, cioè l’eliminazione di un elemento e il conseguente rilascio della cella utilizzata, per renderla disponibile ad ulteriori inserimenti. Gli algoritmi relativi sono mostrati in Fig. 4.19.

next

ID_flip flop

ff_head

ff_memo p q
value

ff_hole

NULL

first_hole

Fig. 4.18

113

Capitolo 4

Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti

Inserimento del flip flop j attivato dal guasto i: a) Ricerca di un posto vuoto nella lista ff_memo: Estrai il puntatore alla prima cella vuota dallo stack ff_hole Incrementa first_hole b) Aggancio della cella alla lista Collega la nuova cella con quella puntata da ff_head[i] Collega ff_head[i] con la nuova cella c) Riempire la cella con il valore e l’ID del flip flop Estrazione di un elemento dalla lista ff_head[i]: a) Leggi ID e valore dalla prima cella puntata da ff_head[i] b) Aggiorna la ff_hole: Inserisci il valore di ff_head[i] in ff_hole Decrementa first_hole c) Elimina i collegamenti con la cella rilasciata: Collega ff_head con la cella collegata alla prima Fig. 4.19 Fault Dropping Finora l’operazione di Fault Dropping è stata gestita con un vettore booleano det[], affiancato alla lista dei guasti, che specificava se un particolare guasto era stato rivelato o meno in un precedente passo di simulazione. Questa soluzione, che ha l’innegabile vantaggio della semplicità, risulta poco efficiente poiché è necessario effettuare un test su det[] prima dell’iniezione di ogni guasto. Se modifichiamo la struttura in modo da ridursi cancellando i guasti che via via vengono rivelati, possiamo eliminare il test, con conseguente aumento di velocità. Sistemando su una lista linkata i guasti possiamo pensare di effettuare l’operazione di fault dropping “by passando” quelli rivelati, come già mostrato nel paragrafo 2.5.2. Questo procedimento, che va bene in una simulazione non parallela, nel nostro caso deve essere modificato. I guasti all’inizio della simulazione sono concatenati in ordine crescente (il guasto G1 punta al G2 che punta al G3 e così via), quando vengono costruiti i pacchetti viene perso questo ordine, di conseguenza occorre memorizzare in un apposito vettore gli indirizzi delle celle dei guasti eccitati; per fare ciò si utilizza il vettore inj_fault[] come schematizzato in Fig. 4.20

114

Capitolo 4

Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti

Fault list G1 G2

con lista concatenata

G3

G4

p2

p3

p4

Vettore inj_fault
Contiene i puntatori ai guasti associati a ciascun bit

Fig. 4.20 Un’altra operazione delicata è quella di eliminazione del guasto dalla lista. In questa fase occorre agganciare la cella precedente a quella da “by passare” con quella successiva. Facendo riferimento alla Fig. 4.21 si nota che per l’eliminazione del guasto G8, non è più sufficiente il puntatore p3 ma occorre anche conoscere il puntatore q proveniente dalla cella precedente; questo problema è risolvibile tramite una lista bi direzionale, cioè organizzata in modo tale che sia possibile accedere all’elemento precedente e seguente rispetto a quello considerato.

Situazione dei puntatori dopo l' eliminazione

G1

G2

q

G3

G4

Cella da eliminare

p2

p3

p4

Vettore inj_fault

Fig. 4.21 Un’ulteriore miglioramento si ottiene se ogni cella della lista contiene tutti gli elementi associati al guasto e precisamente:

115

Capitolo 4

Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti

• • • •

numero di identificazione del guasto; numero di identificazione del descrittore sede del guasto; valore del guasto; puntatore alla lista dei flip flop associata al guasto.

4.4.4 PARSECv4
In questa versione definitiva abbiamo concentrato la nostra attenzione sul problema del ripristino della macchina buona. Il metodo più elementare per effettuare questa operazione, come descritto nel paragrafo 2.5.3, consiste nella duplicazione dello stato totale dopo ogni passo di simulazione; la Fig. 4.22 mostra l’algoritmo nel caso di simulazione parallela.

Per ogni vettore di ingresso { Simulazione macchina buona sui nodi gval[] Per ogni pacchetto da 32 guasti { Copia gval[] in fval[] inietta i 32 guasti Simulazione macchina guasta sui nodi fval[] } } Fig. 4.22: Ripristino con duplicazione Questa procedura implica n_pattern (n_guasti/32) duplicazioni della macchina buona. Un miglioramento che già era stato applicato in SEQSIM e seguenti consiste nel duplicare una volta gval[] e salvare in uno stack ogni descrittore variato in fase di simulazione. Per ripristinare la macchina buona è sufficiente svuotare lo stack. L’algoritmo di Fig. 4.23 descrive questa procedura.

116

Capitolo 4

Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti

Per ogni pattern { Simulazione macchina buona sui nodi gval[] Copia gval[] in fval[] Per ogni pacchetto da 32 guasti { inietta i 32 guasti Simulazione macchina guasta sui nodi fval[] e salva i descrittori variati in uno stack Recupera dallo stack i descrittori inserendoli in fval[] } } Fig. 4.23: Ripristino con stack L’operazione di duplicazione eseguita n_pattern volte è indispensabile per il rilevamento dei guasti e la memorizzazione degli stati; proprio per questo si può pensare di sostituirla con la copiatura delle sole uscite primarie e dei padri dei flip flop. Tuttavia questa variante può risultare meno efficiente a causa di controlli e di ulteriori strutture. In PARSECv4 ci proponiamo di eliminare la fase di duplicazione. Facciamo innanzitutto alcune considerazioni: • Ogni porta è valutata una volta sola per cui il nodo può venire modificato solo una volta; • Per i descrittori in cui l’iniezione del guasto non è stata fatta fisicamente, il valore precedente del nodo di uscita è quello della macchina buona. Diventa allora logico effettuare i confronti tra nodo buono e nodo guasto quando richiesto prima di modificare il valore del nodo. Il problema sorge quando il guasto è iniettato fisicamente in quanto il valore del nodo buono viene perso, la stessa cosa si verifica nell’applicazione dello stato presente relativo a un determinato guasto. PARSECv4 opera in questa direzione tramite le seguenti modifiche: • iniezione dei guasti tramite mascheramento su tutti i descrittori, anche quelli a livello 0; • applicazione dei flip flop tramite mascheramento; • modifica dei confronti tra macchina buona e guasta con confronti tra valore precedente e valore calcolato per quel nodo.

117

Capitolo 4

Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti

Un altro problema riscontrato con questa strategia è quello che denominiamo conflitto di maschere, si verifica nel caso particolare di un flip flop il cui valore viene contemporaneamente modificato dal guasto e dallo stato applicato ad esso corrispondente tramite due maschere agenti sullo stesso bit in modo opposto, l’esempio di Fig. 4.24 chiarisce il concetto.

stato futuro

stato presente
valore buono valore guasto

1111 1101

0000 0000
1

00 1 0 11 0 1

inj1_val inj0_val

Maschere

Conflitto

Fig. 4.24: Esempio di conflitto di maschere

La soluzione consiste nel far predominare l’effetto del guasto su quello dello stato applicato; dal punto di vista implementativo questo comporta la modifica delle maschere relative all’iniezione di un guasto come mostrato in Fig. 4.25.

inietta il guasto sulla porta k Se valore guasto = 1 inj1_val[k] = inj1_val[k] OR maschera 1 inj0_val[k] = inj0_val[k] OR maschera Altrimenti inj0_val[k] = inj0_val[k] AND (NOT maschera) inj1_val[k] = inj1_val[k] AND (NOT maschera) Se present[k] = ABSENT { present[k] = PRESENT inserisci l’indirizzo contenuto in f_eval[k] nella lista di propagazione } Fig. 4.25: Algoritmo di iniezione

1Maschera è una parola di 32 bit in cui solo il bit corrispondente al guasto da esaminare è posto a 1.

118

Capitolo 4

Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti

4.4.5 Risultati sperimentali
Confronto tra la versione compilata e non compilata I tempi di PARSEQv2 e PARSECv1 calcolati su 5000 vettori di prova casuali sono messi a confronto nella tabella di Fig. 4.26 allo scopo di constatare il vantaggio della simulazione compilata. Come si può osservare lo speed up varia da 1.08 a 1.34 se non si tengono in conto i tempi di compilazione.

ISCAS PARSEQv2 PARSECv1 89 [s] [s]
s208 s298 s344 s349 s382 s386 s400 s420 s444 s510 s526 s526n s641 s713 s820 s832 s838 s1423 6,44 4,89 4,34 4,35 22,85 6,06 22,73 14,96 27,16 4,43 29,10 30,01 11,36 11,73 18,70 18,45 35,06 81,00 4,79 4,20 4,06 4,01 18,50 4,63 18,23 11,15 21,71 3,81 24,12 23,98 9,68 10,17 14,45 14,34 26,80 68,89 1,34 1,16 1,07 1,08 1,23 1,30 1,25 1,34 1,25 1,16 1,20 1,25 1,17 1,15 1,30 1,28 1,30 1,17

Fig. 4.26: Confronto tra simulazione compilata e non

119

Capitolo 4

Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti

Tempi di compilazione Riportiamo l’andamento dei tempi di compilazione nel grafico di Fig. 4.29 e nella tabella di Fig.4.27: con l’aumentare della complessità del circuito, osserviamo che questi crescono decisamente.

ISCAS 89
s208 s298 s344 s349 s382 s386 s400 s420 s444 s510 s526 s526n s641 s713 s820 s832 s838 s953 s1196 s1238 s1423 s1488 s1494 s5378 s9234 s13207 s15850 s35932 s38417

tempi [s]
12 16 20 20 21 20 22 24 24 27 27 27 44 47 41 41 50 53 67 65 88 87 86 413 1018 2353 3295 9637 18097

Fig 4.27: Tabella dei tempi di compilazione

120

Capitolo 4

Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti

Confronto tra le versioni di PARSEC La tabella di Fig. 4.28 e il grafico di Fig.4.30 riportano i tempi delle quattro versioni implementate. I risultati sono relativi a 50000 vettori di prova casuali, allo scopo di aumentare i tempi di elaborazione e rendere così più sensibili le differenze nelle quattro versioni che altrimenti non sarebbero così evidenti. Da notare come sui circuiti con copertura maggiore dell’80% l’operazione di fault dropping assuma un’importanza notevole ai fini della riduzione dei tempi di esecuzione (anche del 35%). ISCAS 89
s208 s298 s344 s349 s382 s386 s400 s420 s444 s510 s526 s526n s641 s713 s820 s832 s838 s1196 s1238 s1423 s1488 s1494 s5378 s9234 s13207 s15850 s35932 s38417

Cop. %

Vers. 1 [s]

Versione 2 [s]
1 2

Versione 3 [s]
2 3

Versione 4 [s]
3 4 1 4

58,19 46,72 41,65 95,26 27,64 24,39 97,57 36,95 32,49 97,31 37,9 32,3 24,59 170,07 161,4 92,49 37,95 34,82 24,33 219,1 214,95 45,69 112,77 99,71 21,6 208,3 208,11 99,58 37,5 35,8 18,12 225,75 217,15 18,04 224,9 218,48 90,09 92,48 77,33 88,39 97,45 82,32 62,3 125,4 124,9 62,54 126,8 126,2 38,86 257,4 232,4 99,11 111,74 94,54 98,34 117,01 98,32 72,1 487,79 423,82 88,17 136,13 133,72 88,22 135,01 131,52 71,53 1651,15 1449,55 15,83 9665,84 8677,58 37,13 n.d. n.d. 17,84 n.d. n.d. 89,92 n.d. n.d. 22,15 n.d. n.d.

1,12 28,12 1,13 16,69 1,14 22,33 1,17 22,14 1,05 112,39 1,09 23 1,02 155,86 1,13 69,32 1,00 142,49 1,05 23,69 1,04 154,59 1,03 156,6 1,20 47,66 1,18 52,14 1,00 91,33 1,00 89,59 1,11 157,05 1,18 67,07 1,19 70,02 1,15 300,96 1,02 85,43 1,03 85,7 1,14 1014,94 1,11 6668,57 n.d. n.d. n.d. n.d. n.d. n.d. n.d. n.d.

1,48 26,01 1,46 12,85 1,45 17,91 1,46 18 1,44 98,85 1,51 20,63 1,38 134,89 1,44 62,93 1,46 119,16 1,51 20,37 1,40 141,2 1,40 137,37 1,62 46,23 1,58 50,39 1,37 83,3 1,41 84,84 1,48 149,77 1,41 59 1,40 62,39 1,41 253,8 1,57 77,18 1,53 78,5 1,43 819,33 1,30 5268,18 n.d. 7076,26 n.d. 17819,6 n.d. 3669,7 n.d. 113772

1,08 1,30 1,25 1,23 1,14 1,11 1,16 1,10 1,20 1,16 1,09 1,14 1,03 1,03 1,10 1,06 1,05 1,14 1,12 1,19 1,11 1,09 1,24 1,27 n.d. n.d. n.d. n.d.

1,796 2,151 2,063 2,106 1,720 1,840 1,624 1,792 1,748 1,841 1,599 1,637 2,000 1,934 1,505 1,495 1,719 1,894 1,875 1,922 1,764 1,720 2,015 1,835 n.d. n.d. n.d. n.d.

Fig. 4.28: Tabella di confronto tra le versioni di PARSEC Lo speed up di ciascuna versione fa riferimento a quella precedente e nell’ultima colonna compare lo speed up totale; per gli ultimi circuiti (di dimensione

121

Capitolo 4

Nuove tecniche per la simulazione di circuiti sequenziali sincroni in presenza di guasti

considerevole) è stato eseguito solo PARSECv4 e sono quindi assenti i riscontri corrispondenti.

100000 10000 1000
sec

100 10 1
s208

ISCAS 89
s38417

Fig. 4.29: Grafico dei tempi di compilazione

2,50 2,00 1,50 1,00 0,50 0,00 s208

Speed up 1-2 Speed up 3-4 Speed up 2-3 Speed up 1-4
s9234

Fig. 4.30: Diagramma dei confronti tra le versioni di PARSEC

122

Capitolo 5 Conclusioni
5.1 Lavoro svolto

Sono state presentate tre soluzioni al problema della simulazione guasta per circuiti sequenziali attraverso la realizzazione di altrettanti simulatori. • SEQSIM che si basa su una simulazione Event Driven e ha lo scopo di fornire un algoritmo efficiente e lineare per i circuiti sequenziali. • PARSEQ che sfrutta il parallelismo di 32 bit della macchina su cui abbiamo lavorato e utilizza un algoritmo leggermente più complesso ma in grado di diminuire il numero di eventi da considerare. • PARSEC che al vantaggio della simulazione parallela unisce quello della simulazione compilata. Per effettuare un confronto tra i risultati ottenuti occorre considerare che la versione finale di PARSEC presenta ottimizzazioni software che ne migliorano le caratteristiche prescindendo dalle tecniche di simulazione adottate; si può ritenere che se queste modifiche fossero state realizzate su SEQSIM, il guadagno in termini di tempo tra la prima e l’ultima realizzazione sarebbe stimabile in un ordine di grandezza.

123

Capitolo 5

Conclusioni

5.2

Limiti di utilizzazione dei simulatori

Mentre SEQSIM è di efficienza sicuramente minore degli altri due, PARSEQ e PARSEC sono comparabili e può essere utilizzato l’uno o l’altro a seconda della situazione in cui si deve operare. Se l’esigenza è quella di simulare con un numero limitato di vettori di ingresso (al massimo qualche migliaio, forniti da un ATPG), PARSEQ va sicuramente bene in quanto non necessita di tempi di preprocessing ai fini di compilare il circuito da trattare. Se viceversa occorre operare nel campo della diagnostica e l’obiettivo è per esempio la costruzione di un dizionario dei guasti o la generazione di una firma con il metodo BIST, si rivela necessario lavorare con un numero molto elevato di vettori di prova, anche milioni, dando luogo a grandi tempi di simulazione. In questo caso i tempi di compilazione dei circuiti diventano trascurabili e con PARSEC viene sfuttata la maggiore velocità della simulazione compilata.

5.3

Possibile lavoro futuro

È possibile apportare su PARSEC ulteriori miglioramenti ed estensioni. Si può pensare di agire nella direzione dell’ottimizzazione del codice scrivendolo direttamente in Assembler a scapito però della portabilità del programma su altre macchine. Inoltre si può estendere il simulatore a porte con ritardo diverso da zero. È da considerare infine la possibilità di aumentare il parallelismo di macchina da 32 a 64, operazione a cui noi abbiamo cercato già di predisporre il codice ma che necessita probabilmente di ulteriori accorgimenti.

124

Appendice A I Circuiti di prova ISCAS-89
Presentiamo di sequito la caratteristiche principali dei circuiti esaminati [BBKo89]. ISCAS-89
s208 s298 s344 s349 s382 s386 s400 s420 s444 s510 s526 s526n s641 s713 s820 s832 s838 s953 s1196 s1238 s1423 s1488 s1494 s5378 s9234 s13207 s15850 s35932 s38417

n. PI n. PO n. FF n. Porte Liv. fanout
11 3 9 9 3 7 3 19 3 19 3 3 35 35 18 18 35 16 14 14 17 8 8 35 19 31 14 35 28 2 6 11 11 6 7 6 2 6 7 6 6 24 23 19 19 2 23 14 14 5 19 19 49 22 121 87 320 106 8 14 15 15 21 6 21 16 21 6 21 21 19 19 5 5 32 29 18 18 74 6 6 179 228 669 597 1728 1636 96 119 160 150 158 159 148 196 181 211 194 193 379 393 289 287 390 395 529 508 657 653 647 2779 5597 7951 9772 16065 22179 14 9 20 20 9 11 9 28 11 12 9 9 74 74 10 10 56 16 24 22 59 17 17 25 58 59 82 29 47

____________

__________

fanin
1,750 2,045 1,708 1,721 1,944 2,175 1,978 1,735 1,950 2,009 2,275 2,265 1,450 1,526 2,608 2,608 1,739 1,889 1,910 2,047 1,794 2,122 2,151 1,544 1,446 1,368 1,371 1,600 1,412

1,528 1,917 1,554 1,568 1,810 1,921 1,846 1,542 1,831 1,852 2,163 2,153 1,314 1,395 2,231 2,231 1,556 1,648 1,563 1,648 1,670 2,028 2,056 1,472 1,400 1,450 1,431 1,783 1,482

125

Appendice B Rapporti di potenza delle CPU
Allo scopo di permettere il confronto dei risultati sperimentali con quelli ottenuti tramite altri programmi sviluppati su altri calcolatori, riportiamo in Fig. B.1 i rapporti di potenza, in termini di tempo di elaborazione, tra le CPU più comunemente usate. Bisogna notare che i dati sono puramente indicativi poichè i fattori che possono giocare in questo senso sono molti e difficilmente quantificabili, come ad esempio le istruzioni ammesse da ogni processore, la velocità dei vari dispositivi hardware (RAM o memorie di massa) e il sistema operativo adottato; in ogni caso i dati forniti possono servire per primo confronto.

Sistema DEC VAX 9000 DEC VAX 6000 DEC VAX 8800 Sun 4/390 Sun 4/280 Sun 4/75 Sun 4/65

Rapporto rispetto al DEC VAX 9000 1 0,457 0,286 0,457 0,286 0,8 0,428 Fig. B.1

126

Bibliografia
[ABFr90] M.Abramovici, M.A.Breuer, A.D.Friedman: “Digital System Testing and Testable Design”, Computer Science Press, 1990 F. Brglez, D. Bryan, K. Kozminski: “Combinatorial profiles of sequential benchmark circuits”, ISCAS-89: IEEE International Symposium on Circuits And Systems, Portland, OR (USA), May 1989, pp 1929-1934. Thomas M.Niermann, Wu-Tung Cheng Janak H. Patel: “PROOFS: a Super Fast Fault Simulator for sequential Circuits”, EDAC-90: IEEE European Design Automation Conference, pp 475-479. Wu-Ting Cheng, Meng-Lin Yu: “Differential Fault Simulation A Fast Method Using Minimal Memory”, DAC-89:29th IEEE Design Automation Conference, pp 424-428540. Nikolaus Gouders, Renhard Kaibel: “PARIS: A Parallel Fault Simulator for Synchronous sequential Circuits”, ICCAC-91: IEEE International Conference on Computer Aided Design, pp 542-545. S. J. Hong, “Fault Simulation Strategy for Combinatorial Logic Networks”, Proc., 8th International Symp. on Fault Tollerant Computing, June 1978, pp. 96-99

[BBKo89]

[ChPa90]

[ChYu89]

[GoKa91]

[Hong78]

127

Bibliografia

[KuLi92]

Chen-Pin Kung, Chen-Shang Lin: “Parallel Sequence Fault Simulation for Synchronous Sequential Circuits”, EDAC-92: IEEE European Design Automation Conference, pp 434-438. Hyung Ki Lee, Dong Sam Ha: “HOPE: An Efficient Parallel Fault Simulator for Synchronous sequential Circuits”, DAC-92: 29th IEEE Design Automation Conference, pp 336-340 Hyung Ki Lee, Dong Sam Ha: “An Efficient Forward Fault Simulation Algorithm based on the Parallel Pattern Single Fault Propagation”, ITC-91: 29th International Test Conference, pp 946-954 David M. Lewis: “A Hierarchical Compiled Code Event-Driven Logic Simulator” IEEE Transaction on Computer-Aided Design, Vol 10, No. 6, pp. 726-732, June 91. Thomas M.Niermann, Wu-Tung Cheng Janak H. Patel: “PROOFS: a Fast, Memory Efficient Sequential Circuit Fault Simulator”, IEEE Transaction on Computer-Aided Design, Vol 11, No. 2, pp. 198-207, February 92. Thomas M.Niermann, Wu-Tung Cheng Janak H. Patel: “PROOFS: a Fast, Memory Efficient Sequential Circuit Fault Simulator”, EDAC-90: IEEE European Design Automation Conference, pp 535-540. J. A. Waicukaski, E; B; Eichelberger, D. O. Forlenza, E. Lindbloom, T. McCarthy: “Fault Simulation for Structured VLSI”, VLSI System Design, pp 20-32, December 1985.

[LeHa92]

[LeHa91]

[Lewi91]

[NCPa92]

[NCPa90]

[WEFL85]

128