Generazione BE

1 PROBLEMA
1
Divertissement BE
Ovvero generazione dei segnali BE nell’architettura X86 a 32 bit
Aggiornato al 2 luglio 2014
Al fine di evidenziare alcuni aspetti dell’indirizzamento della memoria e del
trasferimento da/verso i registri della CPU, si cerca di definire la rete responsabile del trasferimento di byte, semiparole (16 bit), o parole (32 bt) –allineate
o meno– con riferimento all’architettura X86 a 32 bit, .
Per rendere il problema trattabile quanto a dimensioni, ma senza perdere di
concretezza, si fa un certo numero di assunzioni semplificative.
Ovviamente, non c’è la pretesa che la rete cui si perviene corrisponda
esattamente alla logica interna di quei processori.
1
Problema
Con riferimento all’architettura X86 a 32 bit, delineare la rete che genera i segnali BE.
Assunzioni
1. Non si considera l’indirizzamento relativo al fetch1 ; si considera solo l’indirizzamento dei dati. Più
specificatamente si considera l’indirizzamento relativo alla fase di esecuzione delle istruzioni MOV.
2. Si assume che la macchina sia a 32 bit.
3. Si considerano le sole operazioni di lettura; le operazioni di scrittura, mutatis mutandis, si trattano
allo stesso modo.
In sostanza si considerano solo queste istruzioni:
mov
mov
mov
mov
rl,m8
rh,m8
rx,m16
erx,m32
dove “r” rappresenta un generico registro tra A, B, C o D, mentre m- rappresenta il nome simbolico una
posizione di memoria corrispondente a un byte (m8), a una semiparola (m16) o a una parola (m32). Si
ricorda che nel caso di semiparole o parole l’indirizzo è quello del byte meno significativo delle medesime.
Per ragioni di chiarezza espositiva, nella parte che segue faremo riferimento al registro A (AL, AH, AX
EAX), tuttavia, come sarà evidente nel seguito, quanto verrà sviluppato si applica immutato agli altri
tre registri B, C e D.
Si dice che una parola è allineata se il suo indirizzo è multiplo di 4 (ovvero se il suo byte meno
significativo è a un indirizzo multiplo di 4); si dice che una semiparola è allineata se il suo indirizzo
(quello del suo byte meno significativo) è un multiplo di 2. I byte per definizione sono allineati.
Si noti che il concetto di allineamento descrive in modo inequivocabile soltanto la relazione che c’è
tra il posizionamento in memoria e il posizionamento nel registro di destinazione nel caso di parole di
32 bit (EAX). Nel caso di byte o di semiparole “allineate” non è detto che ci sia tale corrispondenza.
Consideriamo ad esempio l’istruzione MOV AL,m8 e assumiamo che il byte indirizzato si trovi a un indirizzo
non multiplo di 4. È evidente che il byte viene letto su una corsia del bus dati esterno diversa da quella
corrispondente agli 8 bit meno significativi, mentre, per andare in AL, deve transitare per la parte bassa
del bus dati interno che conduce ai registri. Un analogo ragionamento si può fare per le semiparole
allineate a indirizzi non multipli di 4: esse vengono lette sulla metà più significativa del bus dati esterno,
ma devono transitare sulla parte meno significativa del bus dati interno per finire in AX. Per questo
motivo, nel seguito, si usa il termine “corrispondente” per indicare un’entità (byte o semiparola) che sia
sul bus esterno sia sul bus interno transita su linee di pari peso.
1 Sin dall’8086 il fetch, a parte l’istruzione seguente un salto che poteva trovarsi a un indirizzo non allineato, avviene
sempre per parole allineate.
2 SCHEMATIZZAZIONE
2
Figura 1: Schematizzazione della rete da progettare.
2
Schematizzazione
In Figura 1 viene data una schematizzazione della rete (blocco XFER) che si intende progettare2 . La
figura serve per formalizzare il problema e per definire il significato dei segnali. Più specificatamente
• D31−0 rappresenta il bus dei dati interno, diviso in 4 corsie di un byte (D31−24 , D23−16 , D15−8 ,
D7−0 ). DE31−0 rappresenta il bus dei dati esterno, esso pure diviso in 4 corsie di un byte. In base
alla definizione precedente, un byte di memoria è corrispondente se transita sulle stesse linee dei
due bus (per esempio D7−0 ⇐ DE7−0 .
• Le linee L, H, X e E sono generate dalla logica di decodifica dell’istruzione (non mostrata in figura)
quando viene eseguita (ordinatamente e corrispondentemente) una della 4 istruzioni riportate al
Par.1. Per le parole non allineate e per le semiparole a cavallo a due parole allineate occorrono due
cicli di lettura.
• Assumiamo per semplicità che un ciclo di lettura duri esattamente 1 periodo di clock. Come appena
detto ci sono situazioni in cui si rendono necessari due cicli di lettura; in tali casi denotiamo con TM 1
il primo ciclo e con TM 2 il successivo. Stabiliamo che la logica di decodifica mantenga invariati i
segnali L, H, X e E attraverso i due cicli (se il secondo viene effettivamente eseguito). La generazione
di TM 1 e TM 2 è, almeno concettualmente, banale e fa parte della logica essenziale della CPU (si
veda l’Appendice).
• A1 e A0 rappresentano i due bit meno significativi dell’indirizzo a cui l’istruzione legge in memoria;
essi individuano la posizione all’interno della parola indirizzata.
• BE0 , BE1 , BE2 e BE3 le 4 linee che servono a identificare quale fascia di memoria deve essere letta3 .
• A31−2 è l’indirizzo di parola generato dalla logica di CPU. L’esecuzione di una della 4 istruzioni
di MOV sopra riportate presuppone che venga asserito l’indirizzo di parola e i BE congruenti. In
particolare, se per esempio si legge una parola non allineata, viene prima asserito l’indirizzo di parola
a cui trova la parte meno significativa e i relativi BE, quindi viene incrementato di 1 l’indirizzo di
parola e vengono asseriti i BE necessari a leggere i byte che compongono la parte restante della
2 Ovviamente il blocco XFER è parte della stessa logica di CPU, qui viene schematizzato a parte per formalizzare il
problema, assumendo che la logica della CPU decodifichi le istruzioni e generi i segnali L, H, X, E, A0 , A1 , TM 1 , TM 1 ,
oltre a A31−2 .
3 Per semplicità e per non aggravare la notazione assumiamo che i BE, come tutti gli altri segnali di controllo) siano
attivi in stato di alto, diversamente da quanto accade nel caso concreto dei processori con architettura X86.
3 ACCESSI ALLA MEMORIA
3
parola. Ancora una volta, assumiamo che l’incremento dell’indirizzo di parola (e l’asserzione di
TM 2 sia compito della logica di CPU diversa da XFER.
Nel seguito si adotta questa convenzione: si scrive MOV R,--A1 A0 , dove A1 A0 assumono i valori 00,
01, 10 o 11, per mettere in evidenza la dislocazione (entro la parola) del byte indirizzato. In Figura 2
vengono dati tre esempi di percorsi da bus esterno a bus interno.
L’istruzione MOV AH,--00 legge il byte sulle linee DE7−0 del bus esterno e lo trasferisce verso AH sulle
linee D15−8 del bus interno.
L’istruzione MOV AX,--01 legge 2 byte sulle linee DE23−8 e li trasferisce verso AX sulle linee D15−0 .
L’istruzione MOV EAX,--11 richiede due letture; sulla prima (TM 1 ) il byte meno significativo della
parola risultante viene letto su DE31−24 e trasferito verso AL su D7−0 ; sulla seconda (TM 2 ) i restanti tre
byte vengono letti su DE23−0 . e trasferiti verso la parte restante di EAX (cioè AH e la porzione E) su
D31−8 .
3
Accessi alla memoria
Vengono ora esaminati i singoli differenti accessi alla memoria per le 4 istruzioni elencate in precedenza
in funzione dell’allineamento dell’entità letta. Per ciascuna operazione viene indicato: (i) il codice; (ii) la
rappresentazione sintetica dell’istruzione, da interpretare come la condizione che si verifica quando viene
eseguita l’istruzione stessa; (iii) i BE asseriti; (iv) il trasferimento da bus dati esterno a bus dati interno.
3.1
Accessi che si completano in 1 ciclo
Vengono ora considerate le istruzioni che si completano in 1 ciclo. Esse possono leggere dati in posizioni
corrispondenti o non corrispondenti tra bus dati esterno e interno.
3.1.1
Letture corrispondenti
Sono le letture per le quali l’entità letta passa dal bus dei dati esterno al bus dei dati interno mantenendo
la stessa posizione.
MOV
MOV
MOV
MOV
AL,--00
AH,--01
AX,--00
EAX,--00
3.1.2
L.00
H.01
X.00
E.00
BE0
BE1
BE1, BE0
BE3, BE2, BE1, BE0
D7−0 ⇐ DE7−0
D15−8 ⇐ DE15−8
D15−0 ⇐ DE15−0
D31−0 ⇐ DE31−0
Letture non corrispondenti
Sono le letture per le quali l’entità letta percorre differenti corsie tra bus dei dati esterno e sul bus dei
dati interno.
MOV AL,--01
MOV AL,--10
MOV AL,--11
L.01
L.10
L.11
BE1
BE2
BE3
D7−0 ⇐ DE15−8
D7−0 ⇐ DE23−16
D7−0 ⇐ DE31−24
MOV AH,--00
MOV AH,--10
MOV AH,--11
H.00
H.10
H.11
BE0
BE2
BE3
D15−8 ⇐ DE7−0
D15−8 ⇐ DE23−16
D15−8 ⇐ DE31−24
MOV AX,--01
MOV AX,--10
X.01
X.10
BE2, BE1
BE3, BE2
D15−0 ⇐ DE23−8
D15−0 ⇐ DE31−16
Notare che l’ultima istruzione legge una parola “allineata”, ma non “corrispondente”.
3.2
Accessi che richiedono due cicli
Riguardano la lettura di una semiparola a cavallo tra due parole allineate consecutive e la lettura di
parole non allineate. Si riportano anche i due cicli di clock in cui avvengono le letture, Si tenga conto che
su TM 2 l’indirizzo di parola (quello corrispondente a “--” nell’istruzione) è incrementato di 1 rispetto a
quello in TM 1 .
3 ACCESSI ALLA MEMORIA
4
Figura 2: Schematizzazione di alcuni percorsi e dell’uso dei BE per la selezione. Si invita il lettore a
elencare tutti i possibili casi.
MOV AX,--11
X.11
BE3
BE0
D7−0 ⇐ DE31−24
D15−8 ⇐ DE7−0
su TM 1
su TM 2
MOV EAX,--01
E.01
BE3, BE2, BE1
BE0
D24−0 ⇐ DE31−8
D31−24 ⇐ DE7−0
su TM 1
su TM 2
MOV EAX,--10
E.10
BE3, BE2
BE1, BE0
D15−0 ⇐ DE31−16
D31−16 ⇐ DE15−0
su TM 1
su TM 2
MOV EAX,--11
E.11
BE3
BE2, BE1, BE0
D7−0 ⇐ DE31−24
D31−8 ⇐ DE24−0
su TM 1
su TM 2
3 ACCESSI ALLA MEMORIA
3.3
5
Generazione BE0
Siamo ora in posizione per tracciare la rete genera che i BE. In particolare per quanto riguarda BE0 si
ha che su TM 1 esso deve essere asserito se è verificata la condizione
L.00+X.00+E.00+H.00
mentre deve essere asserito su TM 2 se è verificata la condizione
X.11+E.01+E.10+E.11
Ne consegue la rete di Figura 3. Le reti che generano gli altri BE si ricavano i modo analogo.
Figura 3: Parte della rete XFER che genera BE0.
Risulta facile tracciare la rete di multiplexing della porzione DE7−0 del bus esterno sul bus interno,
come in Figura 4.
Figura 4: Trasferimento di DE7−0 sul bus dei dati interno.
A conclusione di questo paragrafo vale la pena di osservare che l’esserci riferiti al registro A è,
ovviamente, del tutto irrilevante. I BE non dipendono in alcun modo dal registro coinvolto nell’operazione.
4 ABILITAZIONE (PARTI DI) EAX
4
6
Abilitazione (parti di) EAX
Possiamo ora derivare le espressioni per le linee di controllo in ingresso al registro A (che faremo generare
sempre dalla rete XFER di Figura 1, anche se non sono state indicate) che determinano il caricamento di
AL e AH, oltre al caricamento della parte bassa e della parte alta dell’estensione, che, per convenienza,
indicheremo rispettivamente con EAL e EAH4 . Infine si osservi che non serve considerare AX né tantomeno la parte di estensione, perché sono dati rispettivamente dall’unione di AL con AH e di EAL con
EAH
Con riferimento al nostro registro A definiamo i seguenti 4 segnali di abilitazione.
• EnAL il segnale di abilitazione al caricamento di AL.
Il caricamento del registro AL deve essere abilitato sempre e solo su TM 1 tutte le volte che c’è la
condizione L, ovvero la condizione X, ovvero la condizione E.
• EnAH il segnale di abilitazione al caricamento di AH.
Deve essere asserito su TM 1 quando vale la condizione H, ovvero X.00, X.01, X.10, ovvero E.00,
ovvero E.01, ovvero E.10; deve essere asserito su TM 2 quando vale la condizione X.11, ovvero E.11.
• EnEAL il segnale di abilitazione al caricamento della parte bassa dell’estensione di AX (bit EAX23−16 ).
Deve essere asserito su TM 1 quando vale una delle condizioni seguenti: E.00, oppure E.01; deve
asserito su TM 2 quando vale la condizione E.10, ovvero la condizione E.11.
• EnEAH il segnale di abilitazione al caricamento della parte alta dell’estensione di AX (bit EAX31−24 ).
Su TM 1 deve essere asserito se vale E.00; su TM 2 deve essere asserito se vale una di queste condizioni:
E.01, ovvero E.10, avvero E.11.
Riformuliamo quanto sopra in logica delle reti:
EnAL = TM 1 (L + X + E)
EnAH = TM 1 (H + X.00 + X.01 + X.10 + E.00 + E.01 + E.10) + TM 2 (X.11 + E.11) =
= TM 1 (H + (X + E)(A1 A0 + A1 A0 + A1 A0 )) + TM 2 (X + E)A1 A0 =
= TM 1 (H + (X + E)(A1 + A1 A0 )) + TM 2 (X + E)A1 A0 =
= TM 1 (H + (X + E)(A1 + A0 )) + TM 2 (X + E)A1 A0
EnEAL = TM 1 (E.00 + E.01) + TM 2 (E.10 + E.11) =
= TM 1 E(A1 A0 + A1 A0 ) + TM 2 E(A1 A0 + A1 A0 ) =
= TM 1 EA1 + TM 2 EA1 =
= E(TM 1 A1 + TM 2 A1 )
EnEAH = TM 1 E.00 + TM 2 (E.01 + E.10 + E.11) =
= TM 1 EA1 A0 + TM 2 E(A1 A0 + A1 A0 + A1 A0 ) =
= TM 1 EA1 A0 + TM 2 E(A1 A0 + A1 ) =
= TM 1 EA1 A0 + TM 2 E(A0 + A1 ) =
= E(TM 1 A1 A0 + TM 2 (A0 + A1 ))
Nei nomi dei precedenti segnali di abilitazione è presente “A” a indicare che ci si stava riferendo al
registro A. Tuttavia, nelle espressioni alla destra dell’uguale non c’è traccia del registro “A”, dunque le
espressioni trovate sono valide per selezionare le 4 parti di 8 bit di qualunque registro. Per riferirsi ad un
quarto di uno specifico registro basta mettere in AND il selettore del registro con il selettore del quarto
di registro. Si ottiene cosı̀ lo schema di Figura 5 dove con R si è indicato il generico registro (la linea
R è asserita dalla logica di CPU quando il registro di destinazione è R, ovvero uno tra A, B, C, D). I
segnali EnL, EnH, EnEL e EnEH sono i precedenti EnAL, EnAH, EnEAL e EnEAH, mentre i segnali
che escono dalle porte AND sono gli effettivi segnali di abilitazione delle 4 parti del registro R.
4 Si noti che i 16 bit di estensione che trasformano AX in EAX non sono direttamente indirizzabili attraverso il repertorio
di istruzioni di macchina. Essi possono essere letti/scritti solo nelle istruzioni che nominano EAX, cioè assieme ai 16 bit
bassi corrispondenti ad AX. Abbiamo dato i nomi di EL e EH alle due le due metà dell’estensione per poterle abilitare
indipendentemente, a seconda del posizionamento della parola.
5 UN MIGLIORAMENTO
7
Figura 5: Formazione dei segnali di abilitazione di (parti di) un generico registro.
5
Un miglioramento
Lo schema da cui siamo partiti (Figura 1) prevede un unico blocco di cui fa parte sia la logica di controllo
che il percorso dati (datapath). E’ buona norma, anche come pulizia di pensiero, tenere separata la logica
di controllo dal percorso dei dati. Nel caso specifico il percorso dati comprende la memoria M, il blocco
X, e il blocco RF (Register File), come in Figura 6. Il blocco X fa la funzione di multiplexer e corrisponde
a quanto rappresentato in Figura 4; il blocco BEG è responsabile della generazione dei BE e dei comandi
di abilitazione dei registri; esso corrisponde a quanto illustrato in Figura 3 e alla logica del Paragrafo
4. Nel tracciare la figura, le abilitazioni dei singoli registri, coerentemente con la Figura 5, sono state
nascoste nel blocco RF .
Nei nostri ragionamenti si è fatto riferimento alla lettura della memoria, ma non abbiamo mai messo
in evidenza il segnale MRead. È un esercizio banale tenere conto di questo segnale ove serve.
Figura 6: Separazione della logica di controllo dal percorso dati.
Conclusioni
Abbiamo costruito la rete che genera i BE con riferimento all’architettura X86 a 32 bit. Abbiamo
considerato il caso delle sole operazioni di lettura di un dato dalla memoria e abbiamo fatto un buon
5 UN MIGLIORAMENTO
8
numero di assunzioni semplificative. Abbiamo inoltre ricavato le espressioni dei comandi che abilitano il
caricamento del dato letto nelle porzioni del registro di destinazione.
Naturalmente non si pretende che l’effettiva rete sia come quella illustrata; peraltro essa diversamente
dalla nostra sarà integrata nella logica di decodifica ed esecuzione delle istruzioni, che noi abbiamo assunto
esistesse a parte.
Infine, sono possibili alcune variazioni che potrebbero derivare da una analisi più dettagliata del
funzionamento della macchina. Per esempio, abbiamo supposto che nel caso di allineamento che richieda
due cicli di lettura, il dato letto nel primo ciclo venga immediatamente scritto nella parte di registro
deputata ad accoglierlo e che quello letto sul secondo ciclo venga scritto nella (sola) parte rimanente del
registro sul secondo ciclo. Potrebbe essere il caso che il registro venga scritto in una sola volta, utilizzando
un registro di appoggio che serva a parcheggiare il dato letto nel primo ciclo in modo da comporlo con
quello letto nel secondo ciclo per formare il dato completo, effettuando perciò una sola scrittura nel
registro di destinazione.
Appendice
Mostriamo schematicamente come vengono generati TM 1 e TM 2 . Si suppone che l’accesso alla memoria
sia su T3 e che l’eventuale secondo accesso sia su T4.
5
Figura 7: Generazione di TM 1 e TM 2
Lo schema per TM 1 è ovvio: TM 1 viene comunque generato se c’è un accesso alla memoria.
Per quanto riguarda TM 2 si consideri che questo segnale si rende necessario se: (a) deve essere
letta/scritta una parola non allineata (ovvero con uno tra A0 o A1 a 1); (b) deve essere letta/scritta
una semiparola che ha il byte meno significativo posizionato nella posizione più significativa (ovvero
A0 A1 = 1). Naturalmente il precedente ragionamento si basa sull’assunto che su TM 2 la logica di CPU
asserisce l’indirizzo della prossima parola (su A31 − A2 ) mantenendo immutati A1 e A0 .