Architetture dei calcolatori

BUS SINCRONO:

protocollo scandito da cicli di

clock, più veloce ma necessita

sincronizzazione di tutti i

dispositivi collegati

BUS ASINCRONO:

Usa protocollo di handshaking,

più lungo ma velocità dipende

dal dispositivo

bus parelleli

OSS è inoltre possibile dividere i bus in che hanno una linea per ogni bit e

bus seriali che inviano tutti i dati sulla stessa linea

Istruzioni di input / output

inX %dx, %?a?

Input => outX %?a?, %dx

Output =>

Per utilizzare queste istruzioni bisogna prima salvare l’indirizzo del componente della

%dx.

periferica con la quale si vuole interagire in %?a?,

In caso di output bisogna salvare il dato nel registro accumulatore in caso di input

il dato verrà scritto in questo registro.

Invece per trasferire un numero maggiore di dati con istruzione unica si possono usare:

insX %dx

Input => outsX %dx

Output => %RCX,

Il numero di dati da trasferire è contenuto in la prima locazione di memoria in cui

%RDI,

salvare o dalla quale caricare i dati in ovviamente sono istruzioni bloccanti.

OSS l’utilizzo di un registro a 16 bit permette indirizzamento fino 65536 dispositivi

ATTENZIONE Le istruzioni della classe 7 sono implementate a firmware e non sono

disponibili in user space, inoltre x86 permette trasmissione di dati fino a massimo 32 bit

20

Tipologie di interazione tra CPU e periferiche

In tutti gli schemi si fa riferimento a registri I/ODR e I/OAR ma il protocollo è equivalente

usando un solo BUS e quindi i registri MAR e MDR

Busy waiting (firmware, 1 dispositivo)

Basato su protocollo di handshaking, rende trasferimento semi-sincrono bloccando la

CPU per tutto il tempo necessario per lo scambio dei dati.

1. Processore richiede dato tramite I/O RD

2. F/F status invia segnale WAIT

3. SCA dispositivo produce dato e lo posiziona nel suo REG

4. SCO dispositivo disabilita WAIT e CPU legge dato

1. CPU invia segnale I/O WR e carica dato in REG

2. F/F status invia segnale di WAIT

3. SCA dispositivo legge il dato

4. SCO dispositivo disabilita segnale WAIT 21

Busy waiting (firmware, più dispositivi)

1. CPU invia segnale RD (con eventuale I/O) e tramite AND con uscita del decoder

seleziona la periferica

2. Si aziona il buffer-three state del REG e F/F status invia segnale WAIT

3. Quando SCA ha prodotto il dato la SCO attiva scrittura su REG e disabilita WAIT

1. CPU invia segnale WR (con eventuale I/O) e tramite AND con uscita del decoder

seleziona la periferica

2. Si abilita scrittura su REG e F/F status invia segnale WAIT

3. Finita la trasmissione SCO disabilita segnale WAIT

OSS nella realtà non si usa un decoder poiché troppo costoso

OSS gli indirizzi vengono assegnati dal calcolatore durante la fase di boot dello stesso 22

Busy waiting (software)

Per implementare le stesse funzioni via software il WAIT viene messo a terra per

eliminarne gli effetti, il controllo si effettua via software.

1. (hardware viola) CPU invia segnale WR (con eventuale I/O) e scrive 1 sul data bus,

tramite AND con uscita del decoder seleziona la periferica e la avvia

2. (hardware blu) Mentre SCA produce il dato la CPU inizia ciclo di controllo su F/F

status usando segnale RD

3. IF (status == 0) ricomincia ciclo

4. IF (status == 1) seleziona indirizzo per buffer-three state e preleva dato da REG

CODICE ASSEMBLY:

movw $FF_STATUS, %dx #codice per avvertire periferica

movb $1, %al

outb %al, %dx

.aspetta: inb %dx, %al #preleva status

btb $0, %al #copia bit 0 di al nel carry flag

jnc .aspetta #salta su aspetta se carry flag = 0

#se carry = 1 il ciclo termina

movw $DEVICE_IN, %dx

inl %dx, %eax #preleva dato richiesto da periferica 23

1. CPU invia segnale WR (con eventuale I/O), tramite AND con indirizzo seleziona la

periferica e scrive dato su regiatro REG

2. (hardware viola) CPU invia segnale WR (con eventuale I/O) e scrive 1 sul data bus,

tramite AND con uscita del decoder seleziona la periferica e la avvia

ATTENZIONE indirizzo cambia da punto 1 a punto 2

3. (hardware blu) Mentre SCA preleva il dato la CPU inizia ciclo di controllo su F/F status

usando segnale RD (

4. IF (status == 0) ricomincia ciclo

5. IF (status == 1) scambio dati terminato

CODICE ASSEMBLY:

movw $dato, %eax #codice per inviare dato a periferica

movw $DEVICE_OUT, %dx

outl %eax, %dx

movw $FF_STATUS, %dx #codice per avvertire periferica

movb $1, %al

outb %al, %dx

.aspetta: inb %dx, %al #preleva status

btb $0, %al #copia bit 0 di al nel carry flag

jnc .aspetta #salta su aspetta se carry flag = 0

#se carry = 1 il ciclo termina 24

Polling

Utilizzando il Busy waiting per il trasferimento di molti dati su un unica periferica si

mantiene la CPU in blocco per lunghi periodi, per risolvere questo problema si introduce il

polling che permette al processore di interrogare ciclicamente tutte le periferiche

(invece che sempre la stessa) per sapere quando una di queste ha un dato pronto.

CODICE ASSEMBLY:

.poll: movw $STATUS_DEV1, %dx #carica indirizzo prima periferica

inb %dx, %al #preleva status

btb $0, %al #copia bit 0 di al nel carry flag

jc .dev1 #se carry = 1 salto al codice di DEV1

movw $STATUS_DEV2, %dx #carica indirizzo seconda periferica

inb %dx, %al #preleva status

btb $0, %al #copia bit 0 di al nel carry flag

jc .dev2 #se carry = 1 salto al codice di DEV2

#……..

jmp .poll #ricomincia polling

Interrupts

Metodo che permette gestione intelligente delle risorse affidando alle periferiche il

compito di avvertire il processore una volta terminate le operazioni interne.

Permette inoltre gestione delle urgenze tramite priorità.

Il metodo può essere suddiviso in 5 fasi:

abilitazione/disabilitazione interruzioni

1. => settando l'Interrupt flag tramite le

CLRI SETI

istruzioni assembly (pone IF = 0) e (pone IF = 1), bloccare gli interrupt

serve per evitare che questi danneggino la corretta esecuzione dei programmi.

Verifica richieste di interrupt IRQ

2. => le richieste (interrupt request) avvengono in

modo asincrono rispetto alla normale esecuzione dei programmi, il processore

controlla la presenza di richieste alla fine di ogni ciclo istruzioni.

Identificazione sorgente interruzione

3. => ricevuta la IRQ il processore genera

INTA

segnale (interrupt aknowlegment) per avvertire periferica che è pronto.

IDN

Periferica riceve INTA ed invia

(interrupt descriptor number) a CPU.

CPU tramite IDN identifica il driver

IDT

della periferica contenuto nella 3

(interrupt derscriptor table), ogni dispositivo conosce solo il proprio IDN.

Context switch

4. => processore salva registri su stack del processo in esecuzione ed

esegue le altre operazioni per il cambio di contesto

ATTENZIONE importare disattivare interrupt flag durante questa fase

Esecuzione driver

5. => finite le operazioni preliminari il processore esegue il driver del

IRET.

dispositivo, alla fine delle operazioni ripristina lo stato precedente tramite

OSS se vengono effettuate più richieste queste vengono messe in coda e servite una

dopo l’altra prima di ritornare al normale flusso di programma

IDT = è una locazione di memoria (array) visibile solo al kernel nel quale vengono salvati tutti i

3 puntatori ai driver dei dispositivi collegati all'elaboratore 25

EXTRA le operazioni di

determinate periferiche

possono essere più importanti

di altre, per questo è stato

introdotto il concetto di

gestione delle priorità.

Le periferiche vengono

suddivise in livelli (0 più

importante), se due periferiche

mandano la richiesta insieme

viene servita prima quella con

priorità più alta.

Se sono allo stesso livello si

usa una DAISY-CHAIN

(vedere arbitraggio bus)

1. (hardware viola)CPU invia segnale WR (con eventuale I/O) e scrive 1 sul data bus,

tramite AND con uscita del decoder setta il F/F status ed avvia la periferica.

Finita questa operazione ritorna al normale flusso d’esecuzione.

2. (hardware verde) in maniera asincrona rispetto alle operazioni del processore, la SCO

della periferica invia segnale IRQ tramite F/F INT_REQ l

3. La CPU alla fine del ciclo istruzione se IF = 1 invia INTA a periferiche

4. (hardware blu) periferica riceve segnale INTA ed invia IDN

5. Ricevuto IDN processore consulta IDT, esegue context switch ed avvia il driver

corrispondente che può essere implementato in diversi modi

6. Driver lancia IRET e processore ritorna al normale flusso d’esecuzione 26

1. Uguale a lettura, cambia solo il driver

DMAC

Il DMAC è un processore dedicato per il trasferimento di dati tra memorie e/o periferiche.

Per effettuare i trasferimenti necessita programmazione delle sue componenti:

- Direzione di trasferimento, da o verso memoria

- CAR

Indirizzo iniziale della memoria, salvato in (current Address register)

- WC

Formato dati e lunghezza file, salvata in (word counter)

- BURST BUS-STEALING

modalità di acquisizione dei dati, o

4 5

- Indirizzo della periferica

Finita la programmazione si avvia tramite il classico F/F STATUS

A differenza delle modalità viste in precedenza il DMAC può effettuare le trasmissioni ad

ogni ciclo macchina invece di attendere la conclusione di un ciclo istruzioni.

Avendo comunque un bus comune ad ogni interazione il DMAC avverte il processore

MBR

inviando un (memory bus request), se il processore è pronto a ricevere invia in

MBG

risposta un (memory bus grant) e mette in alta impedenza le sue uscite ad

eccezione dei segnali di controllo.

OSS è visto dal processore come una normale periferica al quale nasconde tutti i

dispositivi per i quali agisce da tramite.

Le caratteristiche interne delle varie periferiche non variano, tranne per il F/F status che

diventa in comune per tutti i dispositivi di I/O collegati ad esso.

BURST => DMAC prende il controllo dei bus per tutto il tempo necessario per il trasferimento

4 con conseguente blocco della CPU, equivalente a Busy waiting (utile per cache miss)

BUS-STEALING => DMAC suddivide dati in blocchi inviandoli in più brevi intervalli

5 27

1. Vedere slides macchina a stati finiti

CODICE ASSEMBLY: (nella realtà operazioni eseguite direttamente da ins / out)

movw $WC, %dx #inizializza WC a $NUM_DATI

movl $NUM_DATI, %eax

outl %eax, %dx

movw $CAR, %dx #inizializza CAR a $ID_PERIFERICA

movl $ID_PERIFERICA, %eax

outl %eax, %dx

movw $DMACI/O, %dx #setta F/F I/O per la scrittura (1)

movl $1, %eax

outl %eax, %dx

movw $DMACB-ST, %dx #setta F/F BURST BUS-ST

movl $0, %eax #per lavorare in burst ()

outl %eax, %dx

movw $DMAC_STATUS, %dx #avvia il DMAC

movl $1, %eax

outl %eax, %dx 28

Architettura di un elaboratore moderno 29