Divertissement BE

(1)

1 PROBLEMA 1

Divertissement BE

Ovvero generazione dei segnali BE nell’architettura X86 a 32 bit

Aggiornato al 26 settembre 2013

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 respon- sabile 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’`e 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 fetch¹; si considera solo l’indirizzamento dei dati. Pi`u speciﬁcatamente 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 rl,m8 mov rh,m8 mov rx,m16 mov 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 `e quello del byte meno signiﬁcativo delle medesime.

Per ragioni di chiarezza espositiva, nella parte che segue faremo riferimento al registro A (AL, AH, AX EAX), tuttavia, come sar`a evidente nel seguito, quanto verr`a 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’`e 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 `e 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.

1Sin 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)

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 progettare². 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 deﬁnizione precedente, un byte di memoria `e corrispondente se transita sulle stesse linee dei due bus (per esempio D₇₋₀⇐ DE7−0.

• Le linee L, H, X e E sono generate dalla logica di decodiﬁca dell’istruzione (non mostrata in ﬁgura) 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 e 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 `e, almeno concettualmente, banale e fa parte della logica essenziale della CPU (si veda l’Appendice).

• A1e A0rappresentano i due bit meno signiﬁcativi dell’indirizzo a cui l’istruzione legge in memoria;

essi individuano la posizione all’interno della parola indirizzata.

• BE0, BE₁, BE₂e BE₃le 4 linee che servono a identiﬁcare quale fascia di memoria deve essere letta³.

• A31−2 `e 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 signiﬁcativa 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 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.

2Ovviamente il blocco XFER `e 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.

3Per semplicit`a 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)

2 SCHEMATIZZAZIONE 3

Nel seguito si adotta questa convenzione: si scrive MOV R,--A1A0, dove A1A0 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−0del 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 D₁₅₋₀. L’istruzione MOV EAX,--11 richiede due letture; sulla prima (TM 1) il byte meno signiﬁcativo della parola risultante viene letto su DE₃₁₋₂₄ e trasferito verso AL su D₇₋₀; sulla seconda (T_{M 2}) i restanti tre byte vengono letti su DE₂₃₋₀. e trasferiti verso la parte restante di EAX (cio`e AH e la porzione E) su D₃₁₋₈.

Figura 2: Schematizzazione di alcuni percorsi e dell’uso dei BE per la selezione. Si invita il lettore a elencare tutti i possibili casi.

(4)

3 ACCESSI ALLA MEMORIA 4

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`a letta passa dal bus dei dati esterno al bus dei dati interno mantenendo la stessa posizione.

MOV AL,--00 L.00 BE0 D7−0 ⇐ DE7−0

MOV AH,--01 H.01 BE1 D15−8⇐ DE15−8

MOV AX,--00 X.00 BE1, BE0 D15−0⇐ DE15−0

MOV EAX,--00 E.00 BE3, BE2, BE1, BE0 D31−0⇐ DE31−0

3.1.2 Letture non corrispondenti

Sono le letture per le quali l’entit`a letta percorre diﬀerenti corsie tra bus dei dati esterno e sul bus dei dati interno.

MOV AL,--01 L.01 BE1 D7−0⇐ DE15−8

MOV AL,--10 L.10 BE2 D7−0⇐ DE23−16

MOV AL,--11 L.11 BE3 D7−0⇐ DE31−24

MOV AH,--00 H.00 BE0 D15−8⇐ DE7−0

MOV AH,--10 H.10 BE2 D15−8⇐ DE23−16

MOV AH,--11 H.11 BE3 D15−8⇐ DE31−24

MOV AX,--01 X.01 BE2, BE1 D₁₅₋₀⇐ DE23−8

MOV AX,--10 X.10 BE3, BE2 D₁₅₋₀⇐ DE31−16

Notare che l’ultima istruzione legge una parola “allineata”, ma non “corrisponente”.

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 T_{M 2} l’indirizzo di parola (quello corrispondente a “--” nell’istruzione) `e incrementato di 1 rispetto a quello in T_{M 1}.

MOV AX,--11 X.11 BE3 D₇₋₀ ⇐ DE31−24 su T_{M 1}

BE0 D₁₅₋₈ ⇐ DE7−0 su T_{M 2}

MOV EAX,--01 E.01 BE3, BE2, BE1 D24−0 ⇐ DE31−8 su TM 1

BE0 D31−24⇐ DE7−0 su TM 2

MOV EAX,--10 E.10 BE3, BE2 D15−0 ⇐ DE31−16 su TM 1

BE1, BE0 D31−16⇐ DE15−0 su TM 2

MOV EAX,--11 E.11 BE3 D7−0 ⇐ DE31−24 su TM 1

BE2, BE1, BE0 D31−8 ⇐ DE24−0 su TM 2

(5)

3 ACCESSI ALLA MEMORIA 5

3.3 Generazione BE0

Siamo ora in posizione per tracciare la rete genera che i BE. In particolare per quanto riguarda BE0 si ha che su T_{M 1} esso deve essere asserito se `e veriﬁcata la condizione

L.00+X.00+E.00+H.00 mentre deve essere asserito su TM 2 se `e veriﬁcata 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 DE₇₋₀ del bus esterno sul bus interno, come in Figura 4.

Figura 4: Trasferimento di DE₇₋₀ sul bus dei dati interno.

A conclusione di questo paragrafo vale la pena di osservare che l’esserci riferiti al registro A `e, ovviamente, del tutto irrilevante. I BE non dipendono in alcun modo dal registro coinvolto nell’operazione.

(6)

4 ABILITAZIONE (PARTI DI) EAX 6

4 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 EAH⁴. Infine si osservi che non serve considerare AX né tanto- meno 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 deﬁniamo 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’`e 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 T_{M 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 1deve essere asserito se vale E.00; su TM 2deve 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 = T_{M 1}(H + X.00 + X.01 + X.10 + E.00 + E.01 + E.10) + T_{M 2}(X.11 + E.11) =

= TM 1(H + (X + E)(A1A0+ A1A0+ A1A0)) + TM 2(X + E)A1A0=

= TM 1(H + (X + E)(A1+ A1A0)) + TM 2(X + E)A1A0=

= TM 1(H + (X + E)(A1+ A0)) + TM 2(X + E)A1A0

EnEAL = TM 1(E.00 + E.01) + TM 2(E.10 + E.11) =

= TM 1E(A1A0+ A1A0) + TM 2E(A1A0+ A1A0) =

= TM 1EA1+ TM 2EA1=

= E(T_{M 1}A₁+ T_{M 2}A₁)

EnEAH = TM 1E.00 + TM 2(E.01 + E.10 + E.11) =

= T_{M 1}EA₁A₀+ T_{M 2}E(A₁A₀+ A₁A₀+ A₁A₀) =

= TM 1EA1A0+ TM 2E(A1A0+ A1) =

= T_{M 1}EA₁A₀+ T_{M 2}E(A₀+ A₁) =

= E(TM 1A1A0+ 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.

4Si 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`e assieme ai 16 bit bassi corrispondenti ad AX. Abbiamo dato i nomi di EL e EH alle due le due met`a dell’estensione per poterle abilitare indipendentemente, a seconda del posizionamento della parola.

(7)

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 bloccoXfa 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 `e fatto riferimento alla lettura della memoria, ma non abbiamo mai messo in evidenza il segnale MRead. `E 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

(8)

5 UN MIGLIORAMENTO 8

numero di assunzioni sempliﬁcative. 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 T_{M 1} e T_{M 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 `e ovvio: TM 1 viene comunque generato se c’`e 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 A₀ o A₁ a 1); (b) deve essere letta/scritta una semiparola che ha il byte meno significativo posizionato nella posizione più significativa (ovvero A₀A₁ = 1). Naturalmente il precedente ragionamento si basa sull’assunto che su T_{M 2} la logica di CPU asserisce l’indirizzo della prossima parola (su A₃₁− A2) mantenendo immutati A₁ e A₀.