Architettura dei Processori (Parte 2 della Raccolta)

appuntiDiIngegneria

Architettura dei

Processori

Sommario

1.1. Architettura dei Processori ................................................................................................................2

1.1.1. Principio di Funzionamento della CPU ...........................................................................................2

1.1.2. Processori RISC vs CISC ..................................................................................................................8

1.1.3. Architettura MIPS ..........................................................................................................................9

1.1.4. Progetto di un Processore MIPS Single-Cycle ............................................................................... 12

1.1.5. Progetto di un Processore MIPS Multiple-Cycle ........................................................................... 19

1.1.6. Parallelismo nei Processori .......................................................................................................... 24

1.1.7. Progetto di un Processore MIPS con le Pipeline ........................................................................... 24

1.1.8. Hazard ......................................................................................................................................... 26

1.1.9. Tecniche di Controllo per le Unità di Controllo ............................................................................. 30

1.1.10. Architettura dei Primi Processori Intel ......................................................................................... 32

1.1.10.1. Storia dei Processori Intel ........................................................................................................ 32

1.1.10.2. Processore Intel 8086 .............................................................................................................. 33

1.1.10.3. Processore Intel 80386 ............................................................................................................ 38

1.1.10.4. Processore Pentium I ............................................................................................................... 40

1.1.10.5. Vettore delle Collisioni ............................................................................................................. 45

1.1.10.6. Hibernation Table .................................................................................................................... 48

1.1.11. Parallelismo nelle Moderne Architetture ..................................................................................... 50

1.1.12. Architettura del Processore Pentium IV ....................................................................................... 53

1.1.13. Attacchi Spectre e Meltdown ...................................................................................................... 57

1

1.1.14. Processore ARM .......................................................................................................................... 58

1.1.15. Processori a 32 bit vs Processori a 64 bit ...................................................................................... 61

1.1.16. Processori Intel vs Processori AMD .............................................................................................. 63

1.1. Architettura dei Processori

1.1.1. Principio di Funzionamento della CPU

Come già accennato prima il Processore è l’unità di elaborazione di un calcolatore che legge delle

istruzioni da memoria e le esegue secondo il ciclo di Von Neumann. Il funzionamento di un

Processore può essere schematizzato con la seguente immagine:

L’organizzazione interna di una CPU è caratterizzata dal data path (o Unità Centrale di

Elaborazione), che è costituito da una serie di componenti, tra i quali l’ALU, i registri, e molti bus di

comunicazione. I registri, che sono costituiti da insiemi di Flip-Flop, memorizzano i dati che

vengono poi utilizzati e rielaborati dall’ALU che, a sua volta, riscrive i risultati delle elaborazioni nei

registri stessi attraverso i bus di accesso ai registri; in altre parole un registro è una piccola parte di

memoria utilizzata per velocizzare l'esecuzione dei programmi fornendo un accesso rapido ai

valori usati più frequentemente e/o tipicamente, i valori correntemente in uso in una determinata

parte di un calcolo. si analizzano alcuni dei registri di Processore più importanti:

 MDR (Memory Data Register): Memorizza i dati provenienti e diretti alla memoria. È un

registro a cui l’ALU ha accesso diretto e che contiene momentaneamente i dati da/per la

CPU. L'MDR, insieme al Memory Address Register (MAR), interfaccia la CPU con la memoria

centrale utilizzando i microprogrammi. Anche noto come Memory Buffer Register (MBR).

 MAR (Memory Address Register): Contiene l'indirizzo della locazione di memoria (RAM) in

cui si andrà a leggere o scrivere un dato. In altre parole, il MAR contiene l'indirizzo di

memoria del dato a cui la CPU dovrà accedere.

 PC (Program Counter): Conserva l'indirizzo di memoria della prossima

istruzione (in linguaggio macchina) da eseguire. È un registro 2

puntatore, cioè punta a un dato che si trova in memoria all'indirizzo corrispondente al

valore contenuto nel registro stesso, cioè esso dovrà controllare l’ordine con il quale

vengono eseguite le istruzioni del programma, tenendo presente quale istruzione il

processore sta eseguendo in quel determinato momento.

 IR (Instruction Register): Memorizza il codice dell’istruzione in esecuzione.

 ACC (Accumulatore): È il registro più importante perché è quello che coinvolge quasi tutte

le operazioni logico-aritmetiche. È legato intimamente alla ALU di cui segue la larghezza

che è caratteristica del microprocessore utilizzato, e si occupa di memorizzare i dati in

ingresso e in uscita dalla ALU.

 PSW (Registro di Stato): È un insieme di flag presenti nella CPU che indicano lo stato di

diversi risultati di operazioni matematiche. Questi flag sono comunemente usati per

confrontare e testare condizioni richieste dai programmi.

Il processore utilizza uno Stack per salvare temporaneamente il contenuto dei registri prima

dell’esecuzione di un sottoprogramma (procedura), depositando i parametri passati al

sottoprogramma e l’indirizzo di ritorno. Si ricorda che lo stack (pila) è una struttura dati gestita in

memoria secondo una politica LIFO (last in - first out). La possibilità di gestire uno stack in

memoria è comune a molte architetture. In tal caso il repertorio delle istruzioni prevede le

operazioni PUSH (inserimento di un dato nello stack) e POP (prelievo di un dato dallo stack). Per la

gestione dello stack servono due registri, che sono il BP (Base Pointer) che punta dentro lo stack

(come se si trattasse di una normale area di memoria), e SP (Stack Pointer) che punta sempre alla

testa dello stack e viene aggiornato ad ogni esecuzione di una operazione PUSH o POP.

Il coordinamento tra le varie componenti all’interno della CPU è svolto dall’unità di controllo, ogni

componente esegue solo le azioni che gli vengono richieste da essa; il controllo consiste nel

coordinamento dell’esecuzione temporale delle operazioni sia internamente all’unità di

elaborazione sia negli altri elementi funzionali. L’Unità di Controllo richiede di eseguire le istruzioni

prelevandole dalla memoria:

La prossima istruzione da prelevare è individuata dall’indirizzo di memoria presente nel registro

Program Counter (PC), mentre l’istruzione attualmente in esecuzione è memorizzata nel registro

3

istruzione (IR). Dopo aver prelevato un’istruzione ed aver messo il suo codice nel registro IR, il PC

viene incrementato per fare riferimento all’istruzione successiva. Le istruzioni di un programma

corrispondono ad operazioni elementari di elaborazione, cioè operazioni aritmetiche, operazioni

relazionali (confronto tra dati), operazioni su caratteri e valori di verità, ed altre operazioni

numeriche. L’elaboratore sa svolgere poche tipologie di operazioni elementari ma in modo molto

efficiente, infatti può eseguire decine o centinaia di milioni di istruzioni al secondo. Ogni

processore viene progettato con un set di istruzioni specifico denominato ISA (Instruction Set

Architecture), ed ogni istruzione è implementata da un microprogramma. Ogni istruzione dell’ISA

è contraddistinta da un numero specifico, denominato Operation Code (Op. Code), e contiene dei

parametri che, assieme all’Op.Code, determinano la lunghezza dell’istruzione (in byte), esempi di

istruzioni saranno visti nell’architettura del processore MIPS, ma viene comunque mostrata una

carrellata delle più famose istruzioni ISA:

Ogni istruzione contiene in modo esplicito o implicito l’indicazione dell’istruzione successiva, dove

per “Modo esplicito” si intende che il codice dell’istruzione contiene l’indirizzo della cella di

memoria dove è contenuta l’istruzione successiva. Invece per “Modo implicito” si intende che

l’indirizzo della istruzione successiva è contenuto in un registro interno alla CPU. La sequenza delle

istruzioni è definita dal programma. La CPU esegue un’istruzione mediante il ciclo di elaborazione

fetch-execute, che consiste in 4 fasi:

In termini generali, un processore esegue iterativamente 3 operazioni: preleva (fetch)

un'istruzione dalla memoria primaria, in seguito avviene la decodifica (decode) con cui interpreta

4

l'istruzione, infine la esegue (execute) combinandola coi dati relativi all'istruzione stessa. Gli

eventuali risultati nei registri possono anche essere scritti sul bus dati dall’Unità di Controllo,

diretti verso la memoria o verso le periferiche di I/O. In questo modo il Processore esegue

sequenzialmente istruzioni che danno vita a Threads e Processi, sotto la supervisione del Sistema

Operativo attraverso lo scheduler. L'estrema velocità di elaborazione dei Processori moderni

rispetto alla velocità di accesso intrinseca alla Memoria rende quest'ultima un collo di bottiglia in

fase di progettazione dell'intero sistema di elaborazione. Si analizzano con maggiore dettaglio le

prime tre fasi:

Per prima cosa il Sistema Operativo, dopo aver ricevuto comando dall'esterno (come un click su

un'icona, o Enter, etc), avvia l'eseguibile che inserisce all'interno del PC (Program Counter)

l'indirizzo associato alla prima cella di memoria contenente l'istruzione desiderata per l'esecuzione

delle fasi successive del programma; durante la fase di Fetch (Preleva) l’unità di controllo copia il

valore del PC nel registro Memory Address Register (MAR) in modo tale da poter porre sul bus

degli indirizzi il valore del PC e leggere dalla memoria il codice dell’istruzione da eseguire. Il codice

dell’istruzione letta viene caricata dalla memoria principale mediante Data Bus nel Memory Data

Register (MDR), dal quale poi viene copiata nel registro IR (Instruction Register) in modo tale che

essa possa essere decodificata ed eseguita. Quindi ricapitolando la fase di Fetch consiste in tre

  

trasferimenti successivi: PC MAR, Memoria(MAR) MDR, e MDR IR. Segue subito la fase di

Decode (decodifica) che ha lo scopo di interpretare l’istruzione presente nell’IR, leggerne i

parametri (che vengono memorizzati nei rispettivi registri dell’ALU) e leggerne l’OP. Code, grazie al

quale l’Unità di Controllo comprende con che tipo di istruzione essa ha a che fare, e quindi di

conseguenza sa come agire nell’esecuzione. Al termine della fase di Decode, il Program Counter

aumenta di 1 l'indirizzo contenuto in memoria per indicare che la prossima istruzione sarà

contenuta all'interno di questa nuova cella di memoria. La fase di Fetch è eguale per tutte le

istruzioni che ovviamente si differenziano nella fase di esecuzione. La figura successiva mostra il

comportamento di queste prime due fasi: 5

Nella fase di Execute (Esecuzione) viene avviato il microprogramma relativo all’OP. Code

dell’istruzione letta dall’IR, assegnando le varie azioni ai rispettivi componenti. Ovviamente il

comportamento di questa fase differisce in base alla tipologia di istruzione letta, per cui maggiori

dettagli saranno forniti durante l’illustrazione dell’Architettura MIPS. Occorre sempre leggere i dati

necessari per l’esecuzione dell’istruzione dalla memoria sfruttando i registri MAR e MDR, e

caricarli nei registri dalla quale l’ALU preleverà i dati per completare le operazioni. Attenzione al

fatto che l’istruzione successiva non è per forza nella successiva cella di memoria (per quel caso è

necessario sfruttare lo Stack).

Al termine della fase di Execute gli eventuali risultati, posti nei Registri, possono essere scritti sul

Bus dall’Unità di Controllo, o verso la Memoria, o verso l’I/O nella fase di Store (Memorizzazione).

Il tutto può essere riassunto con la seguente immagine: 6

Dall’esecuzione dei cicli, composti da queste quattro fasi, si ricava anche la velocità del processore,

che solitamente è espressa in GHz: i cicli di lavoro vengono gestiti da un “clock”, una sorta di

orologio interno, e ad ogni tick di questo orologio la CPU processa una istruzione. La velocità di

clock si misura in cicli al secondo, e un ciclo per secondo è 1 Hz. Un processore da 3.2 GHz è un

processore che può elaborare 3.2 miliardi di operazioni (o cicli) al secondo: quindi fetch, decode,

execute e store eseguiti per 3.2 miliardi di volte in un secondo.

L’unità aritmetico logica ALU rappresenta l’apparato muscolare di un calcolatore, il dispositivo cioè

che esegue le operazioni aritmetiche come la somma o la sottrazione, o quelle logiche, come

l’AND o l’OR

Una semplice ALU è realizzabile a partire da cinque blocchi elementari, che sono le porte logiche

AND, OR, NOT, Multiplexer, e Full Adder.

Di un processore l’obiettivo importante è quello di minimizzare il Tempo di CPU che viene

impiegato per eseguire un programma, che è calcolato come:

( )( )

= ⋅ =

È possibile calcolare questo tempo eseguendo il programma e misurando quanto tempo esso

impiega, in generale la frequenza di clock è un informazione data dal Datasheet della CPU, il

7

Numero di istruzioni invece si può misurare facendo girare il programma in un simulatore anziché

sull’hardware, ed infine il numero di colpi di clock necessari per eseguire un’istruzione variano in

base al tipo di istruzione e al set di istruzioni (ISA CISC oppure RISC). IL Tempo di CPU è un

importante requisito non funzionale, ma anche la grandezza delle istruzioni lo è perché di devono

far rientrare tutte le istruzioni sull’area del chip, occorre quindi trovare il migliore trade-off tra

spazio e tempo. 1.1.2. Processori RISC vs CISC

Si può considerare la CPU come una “black box” che si occupa dell’esecuzione delle operazioni a

velocità elevatissime, se si decide di “aprire” questa scatola all’interno quello che si trova è un set

di istruzioni (ISA) che può essere di 2 tipi. CISC o RISC. Il CISC (Complex instruction set computer)

indica un'architettura per microprocessori formata da un set di istruzioni contenente istruzioni in

grado di eseguire operazioni complesse come la lettura di un dato in memoria, la sua modifica e il

suo salvataggio direttamente in memoria tramite una singola istruzione. Le istruzioni quindi sono

più complesse a livello di Assembly, non hanno dimensione fissa, occorrono più cicli di clock per

eseguire un’istruzione, la tecnica di controllo utilizzata è una Logica Microprogrammata, e lo

spazio occupato sul chip è elevato, il che vuol dire meno spazio per aggiungere pipe, registri, etc.

Risulta quindi difficile realizzare compilatori ottimizzanti per questo tipo di architetture. Esempi di

architetture CISC sono Intelx86, Pentium, P6, Motorola 68000. Il mondo dei PC desktop e laptop è

dominato dalla famiglia Intel x86 che continua ad adottare lo stile CISC per mantenere la

compatibilità con le applicazioni. Il RISC (Reduced Instruction Set Computer) invece indica

un'architettura per microprocessori formate da un set di istruzioni contenente istruzioni in grado

di eseguire operazioni semplici che possono essere eseguite in tempi simili. Quindi a differenza del

CISC, il RISC presenta un set ridotto di istruzioni che però sono più semplici e tutte della stessa

lunghezza (con un numero di operandi fisso), e di conseguenza richiedono pochi cicli di clock per

essere eseguite, ed occupano meno spazio sul chip, per cui è possibile distribuire meglio le risorse

avendo pipe più lunghe, cache più grandi, più superscalarità, etc. La fase di Decode è breve e

senza microprogrammi da eseguire, ogni istruzione è eseguita direttamente in hardware con pochi

cicli di clock utilizzando come Tecnica di controllo una Logica Cablata. Esempi di architetture RISC

sono AVR, PIC, ARM, DEC Alpha, PA-RISC, SPARC, MIPS RX000, IBM PowerPC. Ricapitolando

quindi:

 Un’elaborazione RISC appare nettamente più veloce (almeno di un ordine 10).

 Un’istruzione CISC - con molti passi nel data path - equivale a numerose istruzioni RISC con

data path singolo.

 I programmi per ISA RISC sono molto più lunghi di analoghi programmi per ISA CISC.

Prima degli anni 80 si riteneva che repertori estesi di istruzioni fossero preferibili, per facilitare la

costruzione di compilatori. L’uso efficiente della memoria centrale (allora costosa e poco

8

performante)