Fabio Casale, Matteo Sosso
ARCHITETTURA
IA-64
ARCHITETTURA IA-64
Introduzione all’ IA-64
EPIC nasce dall’analisi delle caratteristiche dalle architetture esistenti
CISC RISC VLIW
EPIC
E’ necessario cambiare architettura!
IA 64 e x86 non sono compatibili a livello binario
Possibile compatibilita’ con codice a 32 bit tramite emulatori o traduttori binari.
Necessita’ di nuovo software (sistemi operativi, compilatori ecc.)
Nuovo set di istruzioni orientate al parallelismo ( ILP )
ARCHITETTURA IA-64
le limitazioni del x86
Problemi x86 CISC:
- parallelismo implementato via hardware
- predizione dei salti
- limitate risorse interne
- latenza memoria
- complessita’ hardware
ARCHITETTURA IA-64
… sono state risolte
Esecuzione parallela architettura EPIC
Predizione dei salti: uso dei predicati (predicative execution)
Grandi cache suddivise su piu’ livelli, istruzioni di
precaricamento dati direttamente nel codice (a compile time
invece che a run time)
Grande disponibilita’ di risorse, registri rotanti, pagine di
memoria a dimensione variabile (indirizzamento)
Chiamate a subroutine e passaggio dei parametri (register stack
engine)
Implementazione dei cicli
ARCHITETTURA IA-64
Parallelismo delle istruzioni
VECCHIE ARCHITETTURE
- unita’ hardware aggiuntive per scegliere parallelo gruppi di istruzioni da eseguire in parallelo.
- natura intrinsecamente sequenziale del set di istruzioni x86.
ARCHITETTURA EPIC ( Explicitly Parallel Instruction Computing )
- la scelta dei gruppi da eseguire parallelamente e’ presa dal compilatore.
- non serve piu’ hardware aggiuntivo che esegue controlli a run time.
- il nuovo set di istruzioni permette di creare un codice contente riferimenti espliciti ai gruppi
eseguibili in parallelo.
ARCHITETTURA IA-64
Predizione dei salti
VECCHIE ARCHITETTURE
- dispositivi hardware aggiuntivi per la predizione dei salti
- in caso di fallimento e’ necessario svuotare la pipeline e ricaricare le nuove istruzioni
- piu’ lunga e’ la pipeline maggiore e’ lo svantaggio portato da una predizione errata
IA-64
- introduzione dei predicati ( predicative execution )
- possibilita’ di eseguire entrambi i flussi di un salto
- il compilatore puo’ aggiungere nel codice istruzioni per aiutare la predizione dei salti
ARCHITETTURA IA-64
Predizione dei salti
Esempio di salto eseguito nelle architetture tradizionali e nella nuova IA-64
codice stile C
Sistema dei predicati
if a[i].ptr != 0
b[i]=a[i].l;
else
b[i]=a[i].r;
i++;
Architettura tradizionale
IA-64
load a[i].ptr
load a[i].ptr
p1, p2=CMP a[i].ptr != 0
p1, p2=CMP a[i].ptr != 0
jump if p2
load a[i].l
store b[i]
then
jump
load a[i].r
store b[i]
i = i +1
else
p1
load a[i].l
p2
load a[i].r
p1
store b[i]
p2
store b[i]
i = i +1
ARCHITETTURA IA-64
Predizione dei salti
Il compilatore ha la possibilita’ di inserire nel codice informazioni
per aiutare la predizione dei salti.
Indizi disponibili per la predizione dei salti:
- Strategia di predizione:
- Taken / Not Taken: salto probabile / improbabile
- Static / Dynamic: se static utilizza il valore Taken/Not Taken, lascia all’algoritmo di
predizione la scelta
- Prefetch Sequenziale:
- Few / Many: indica la quantita’ di istruzioni da precaricare nel ramo prescelto
ARCHITETTURA IA-64
Organizzazione della memoria
Con l’aumento della velocita’ dei processori e’ venuto a crearsi il problema del tempo di latenza
delle memorie. Per questo motivo sono state introdotte le memorie cache.
In caso di lunghe pipeline, se un solo elemento della pipeline ha bisogno di un dato residente in
memoria tutta la pipeline deve fermarsi per attenderne il caricamento.
VECCHIE ARCHITETTURE
- adozione di memorie cache
- introduzione di circuiti hardware per predire quali dati della memoria debbano venir caricati in
cache ( hardware prefetch )
- necessita’ di controllare la coerenza fra dati in cache e in memoria
IA-64
- adozione di memorie cache di grandi dimensioni e divise su piu’ livelli ( tre livelli per Itanium )
- set di istruzioni specifico per la verifica della coerenza fra cache e memoria.
- possibilita’ di gestire il precaricamento in cache dei dati tramite istruzioni inserite al momento della
compilazione.
ARCHITETTURA IA-64
Control speculation
Permette al compilatore di caricare i dati prima che il codice ne abbia effettivamente bisogno
questo permette di ridurre la perdita di tempo dovuta alla latenza delle memorie e di eseguire
istruzioni in parallelo al caricamento dei dati.
Esistono due istrizioni speciali:
- speculative load (ld.s)
- check (check.s)
ARCHITETTURA IA-64
Control speculation
codice stile C
Control speculation
t1=t1+1;
if t1>t2
{
}
Architettura tradizionale
IA-64
j=a[t1-t2];
add t1 + 1
add t1 + 1
b[j]++
cmp t1 > t2
ld.s r8=a[t1-t2]
jump
cmp t1 > t2
exception
detection
jump
load a[t1-t2]
check.s r8
load b[j]
load b[j]
add b[j] + 1
add b[j] + 1
exception
delivery
ARCHITETTURA IA-64
Grande disponibilita’
di risorse interne
L’architettura IA-64 mette a disposizione un elevato numero di
risorse interne:
- grande numero di registri interni (interi, float, flag)
- registri rotanti
- stack sui registri
- possibilta’ di indirizzare pagine di memoria di dimensione
variabile
ARCHITETTURA IA-64
Grande numero di registri
128 registri a 64 bit per gli interi di cui 32 statici e 96 rotanti
128 registri a 82 bit per i numeri in virgola mobile di cui 32 statici e 96 rotanti
64 registri per i predicati di cui 16 statici e 48 rotanti
8 registri per i salti
128 registri speciali
1 registro CFM
ARCHITETTURA IA-64
Grande numero di registri
Schema dei registri interni dell’IA-64
ARCHITETTURA IA-64
Registri rotanti
I registri vengono usati come fossero uno stack rotante.
Nei momenti di inutilizzo della memoria centrale si effettua un
salvataggio/ripristino dei registri più vecchi (quelli più lontani dalla posizione
della finestra corrente). Man mano che la finestra avanza, la logica di controllo
libera dei registri davanti ad essa per permettere altri avanzamenti, e vicerversa
man mano che torna indietro il valore dei vecchi registri viene ripristinato. In
conclusione il risultato di tutto ciò è una ruota di registri virtualmente infinita.
La copia dei dati in memoria viene eseguita via hardware in background senza
l’intervento dell’applicazione.
ARCHITETTURA IA-64
Registri rotanti
Registro virtuale = registro fisico – registro di rotazione base (RRB)
ARCHITETTURA IA-64
Chiamate a subroutine
Il passaggio dei parametri avviene attraverso il banco dei registri, organizzato in
una struttura a stack rotante di 96 registri. Ciascuna subroutine ha accesso ad un
numero programmabile di registri consecutivi (la sua finestra), i primi saranno i
registri dei parametri ricevuti dalla subroutine chiamante, gli ultimi quelli di
uscita verso altre subroutine. Quando una subroutine A chiama un'altra
subroutine B, la finestra scorre in avanti, così che quelli che per A erano i registri
dei parametri di uscita, per B sono i registri dei parametri di ingresso. Al ritorno
dalla subroutine la finestra scorre indietro, ripristinando la finestra precedente.
ARCHITETTURA IA-64
Chiamate a subroutine
Schema del passaggio di parametri fra subroutine tramite il meccanismo dello
stack sui registri.
ARCHITETTURA IA-64
Indirizzamento della memoria
E’ possibile indirizzare fino a 18 miliardi di GB di memoria direttamente
2^64 = 18.446.744.073.709.551.616 Byte
L’ IA-64 puo’ indirizzare pagine di memoria di dimensione variabile fino a
256MB.
L’ IA-32 permetteva di indirizzare solo pagine di dimensione fissa di 4KB.
L’ IA-64 mette a disposizione del Sistema Operativo registri per suddividere lo
spazio di indirizzamento fino ad un massimo di 8 aree.
ARCHITETTURA IA-64
Conclusioni
Grande passo in avanti rispetto all’architettura x86
Elevata potenza specifica (maggiore efficienza a parita’ di clock)
Necessita’ di riscrivere completamente il software (Sistemi Operativi,
Compilatori, ecc.)
Viene delegato molto “lavoro” ai compilatori.
L’unico processore con architettura IA-64 attualmente in commercio e’
l’ITANIUM di Intel.