Architetture di un elaboratore e reti

Transcript

Architettura
Indice:
Architettura 1 – Architettura degli elaboratori (3 / 10 / 2006)............................................4
Livelli di astrazione......................................................................................................................4
Architettura di Von Neumann..................................................................................................4
La CPU ............................................................................................................................................5
La memoria ...................................................................................................................................5
Rappresentare gli interi .............................................................................................................6
Rappresentazione numeri in virgola mobile.........................................................................9
Circuiti logici...............................................................................................................................10
Circuito per la somma di 2 numeri........................................................................................13
Circuiti sequenziali ....................................................................................................................14
Il 3-state .......................................................................................................................................15
Ritornando ai registri................................................................................................................15
Architettura MIPS e Assembler ..............................................................................................17
La memoria 2 ..............................................................................................................................18
Assembler parte 2......................................................................................................................20
Ciclo fondamentale ...................................................................................................................21
Struttura dei registri del MIPS 32..........................................................................................22
Esempio completo di una istruzione di somma .................................................................22
Assembler parte 3......................................................................................................................23
Flusso di istruzioni.....................................................................................................................23
Pseudoistruzioni ........................................................................................................................27
Convenzioni di uso della memoria........................................................................................28
Implementazione hardware delle istruzioni macchina ....................................................29
Unità Operativa (DataPath) multiciclo.................................................................................33
Simulatore SPIM per architettura MIPS32 ..........................................................................36
Unità di controllo: macchina a stati finiti ............................................................................38
Supporto alle eccezioni / interruzioni ..................................................................................42
Le periferiche e gli interrupt...................................................................................................44
Il gestore delle eccezioni .........................................................................................................48
DMA (Direct Memory Access) ................................................................................................51
Modularizzazione del software ..............................................................................................53
Esercitazioni ................................................................................................................................56
Architettura 2 – Reti (8 / 1 / 2007) ............................................................................................60
Introduzione (8 / 1 / 2007)......................................................................................................60
Accesso alla rete.........................................................................................................................60
Dentro la rete..............................................................................................................................60
Circuit Switching........................................................................................................................61
Packet Switching (9 / 1 / 2007)..............................................................................................61
Reti datagram e a circuito virtuale........................................................................................62
Ritardi e sorgenti di ritardo ....................................................................................................62
I Livelli ..........................................................................................................................................63
Esercitazione del 10 / 1 / 2007 ...............................................................................................64
2
Quaderno virtuale di teoria
Strato di applicazione (15 / 1 / 2006)...................................................................................67
Protocollo http (15 / 1 / 2006)...............................................................................................68
Protocollo ftp (16 / 1 / 2006) .................................................................................................71
Posta elettronica (16 / 1 / 2006)............................................................................................72
DNS (domain name system) (16 / 1 / 2006) .......................................................................74
Web cache 2 (22 / 1 / 2007)...................................................................................................75
P2P (22 / 1 / 2007) ....................................................................................................................75
eMule (22 / 1 / 2007)................................................................................................................76
Strato di trasporto (22 / 1 / 2007).........................................................................................77
Principi di trasporto affidabile (22 / 1 / 2007)...................................................................78
Esercitazione del 24 / 1 / 2007 ...............................................................................................84
Principi di trasporto affidabile 2 (29 / 1 / 2007) ...............................................................88
TCP (Generalità)(29 / 1 / 2007) ..............................................................................................90
Esercitazione del 31 / 1 / 2007 .............................................................................................100
Strato di rete (19 / 2 / 2007).................................................................................................103
Router (19 / 2 / 2007).............................................................................................................104
Protocollo IP (20 / 2 / 2007) .................................................................................................107
IPv6 (20 / 2 / 2007) .................................................................................................................114
Algoritmi di routing (26 – 27 / 2 / 2007)...........................................................................115
Strato di link e strato fisico (27 / 2 / 2007 – 6 / 3 / 2007) .............................................122
Multimedialità in rete (12 – 13 / 3 / 2006)........................................................................134
Esercitazioni del 28 / 2 / 2007 – 7 / 3 / 2007 – 14 / 3 / 2007........................................138
Appendici collegate:
Appendice 1 – Datapath
Appendice 2 – FSM Diagram
Appendice 3 – Gestione delle eccezioni
Appendice 4 – P2P (peer to peer)
ultima modifica: 16/11/2006
(Contiene 0 errore/i)
Dati riguardanti il quaderno virtuale:
Ultima sezione aggiunta: “Esercitazioni varie” in data 16 / 3 / 2007
Errori: Nessun errore rilevato
3
Architettura
Architettura 1 – Architettura degli elaboratori (3 / 10 / 2006)
Livelli di astrazione
•
•
Fisica dello stato solido
(spiega il funzionamento dei semiconduttori)
Elettronica digitale
(permette di eseguire operazioni logiche)
0
0
1
•
•
(AND)
Architettura hardware (Alu, registri,…)
(si tiene conto anche della fisica che si utilizza [i ritardi di propagazione del
segnale,..]
Esempio: se ho 1000 file l’hardware necessario per eseguire l’Or di questi fili sarà
differente rispetto a quello per eseguire l’Or di due fili
Instruction Set Architecture (ISA [noi considereremo il MIPS])
(Quella usata normalmente oggi è l’Intel Alchitecture a 32 bit)
Programmazione Assembler Æ utilizza il set di istruzioni predefinito del circuito
Normalmente il programmi vengono scritti in codice ad alto livello (Java, C++,…), il che
presuppone che la macchina sia in grado di eseguire questo codice; in realtà non esiste una
macchina che può fare le operazioni scritte in codice ad alto livello in modo nativo. Per far si che un
pc esegua le istruzioni che noi abbiamo programmato occorre un compilatore che trasformi il
linguaggio ad alto livello in un linguaggio a basso livello (linguaggio macchina)
.C
Compilatore
.exe
Tramite diversi compilatori lo stesso codice può essere adattato per ISA differenti
Intel Architecture a 32 bit (Intel e AMD)
MIPS
.C
PowerPC
Architettura di Von Neumann
Un calcolatore è costituito da tre blocchi fondamentali:
CPU
MEMORIA
Dispositivi
I/O
BUS
Il Bus è un insieme di fili
che trasporta le
4
informazioni tra i vari
blocchi
Questa struttura è detta: Architettura di Von Neumann.
Ho una memoria sola dove memorizzo sia dati che istruzioni quindi sarà il Sistema Operativo a dire
cosa posso o non posso fare con i dati o con le istruzioni e come le devo elaborare.
La CPU
Registri: locazioni di
memoria con un numero
predefinito di bit rispetto
all’architettura
Unità di controllo: prende una
istruzione, capisce cosa c’è dentro e
dice alla ALU cosa fare (ha bisogno di
2 registri speciali)
Instruction Register
ALU, unità aritmetico logica.
Si disegna così perché ci sono
2 operandi e un risultato
Program Counter: memorizza l’indirizzo di memoria
dell’istruzione da controllare e passa alla successiva
quando quella precedente è stata eseguita
Questa è una visione semplificata di un calcolatore moderno (può avere più ALU, ha unità
specifiche per numeri non interi, può eseguire più istruzioni contemporaneamente)
La memoria
È un insieme di parole indicizzate di dove risiedono i dati
CPU
Una parte della memoria viene usata per ricopiare alcune informazioni che
più probabilmente la CPU controlla e richiede. Questa parte di memoria si
chiama CACHE.
5
Architettura
I componenti della CPU (registri, …) sono visibili in programmazione Assembler, mentre la Cache
non lo è. Alcuni programmi disabilitano la Cache perché se no il loro funzionamento sarebbe
rallentato
Il BUS si divide in: Address Bus, Data Bus e Control Bus.
Rappresentare gli interi
Facciamo finta di avere 3 bit.
Rappresentazione degli interi senza segno:
0 0 0 0
0 0 1 1
0 1 0 2
0 1 1 3
1 0 0 4
1 0 1 5
1 1 0 6
1 1 1 7
Rappresentazione con modulo e segno
Per convenzione i valori con segno positivo hanno bit più significativo 0 mentre quelli negativi
hanno bit più significativo 1.
0 0 0 0
0 0 1 1
0 1 0 2
0 1 1 3
1 0 0 0
1 0 1 -1
1 1 0 -2
1 1 1 -3
La rappresentazione in modulo e segno dei problemi:
• Ha due serie di bit per indicare lo zero (±0)
• Logica complicata per vedere se un numero è maggiore di un altro
• Alcune operazioni matematiche non riescono
Esempio: 1 – 2 = –1
0 0 1
1 1 0
1 1 1
Ottengo come risultato –3. Cosa che non è possibile
Allora venne inventata la notazione in Complemento a 2: un numero a positivo si rappresenta
come a, mentre il negativo –a = 2n – a
0
0
0
0
1
1
1
1
6
1
1
0
0
1
1
0
0
1
0
1
0
1
0
1
0
3
2
1
0
-1
-2
-3
-4
•
•
•
2+1=
0 1
0 0
0 1
Ho un’unica rappresentazione per lo zero
I moduli mi dicono qual è il valore più grande tra i numeri dello stesso segno
La somma funziona
0
1
1
=3
Quindi la somma funziona
a – b = a +(-b)
altro non è che la somma di a e del complemento a 2 di b.
Quanti numeri diversi posso rappresentare con n bit:
2(n – 1) – 1
(posso rappresentare +3 e non +4)
Mentre il numero più negativo è dato da:
–2(n – 1) = –4
Se faccio 3 + 2 = –3
0 1 1
0 1 0
1 0 1
Ottengo un OVERFLOW perché il 5 non lo posso rappresentare
La macchina non sa se il risultato è giusto ma deve essere in grado di segnalare l’errore.
A b
|a+b|
Risultato
(n – 1)
+ + Se > 2
–1
–
Ottengo un risultato con 1 nel bit significativo, quindi il
risultato avrà segno negativo
(n – 1)
– –
Se > –2
+
Ottengo un risultato con 0 nel bit più significativo, quindi il
risultato avrà segno positivo
– +
/
/
Non può esserci condizione di Overflow
Condizioni di Overflow:
• I due operandi hanno lo stesso segno; il risultato ha segno opposto
• Il Carry In (riporto sul) bit di segno è diverso dal carry out
In uscita dal calcolo
ho un carry out che
vale 1
Il carry in (dell’ultimo calcolo) è
uguale al carry out (1 = 1) quindi non
ho situazione di overflow.
Carry In
(1)
1 … …
1 … …
1 … …
Arrivo qui è ho un riporto (che sarebbe il
carry out del calcolo precedente).
Esempio: 1+1+1=1 riporto 1 (questo è il
carry out, che sarà il carry in del calcolo
successivo)
7
Architettura
Carry In
In uscita dal calcolo
ho un carry out che
vale 1
(0)
1 … …
1 … …
0
…
Il carry out è diverso dal carry in (1 ≠ 0) quindi mi trovo in una situazione di overflow.
Come faccio a rappresentare il complemento a 2 del numero
–a = 2n – a
Prendo un numero, partendo dal bit meno significativo; fino a che ci sono zeri li lascio, quando
incontro il primo 1 lo lascio e dal successivo bit faccio il complemento, cioè se c’è 0 scriverò 1 e
viceversa.
0
0
0
0
1
1
1
1
1
1
0
0
1
1
0
0
1
0
1
0
1
0
1
0
3
1 0 1 -3
2
1 1 0 -2
1
1 1 1 -1
0
0 0 0 0
Ö
-1
0 0 1 1
-2
0 1 0 2
-3
0 1 1 3
-4
1 0 0 -4
Sul -4 non può funzionare perché il +4 non è nel range di valori rappresentabili
Come metodo va bene per gli esseri umani ma non per i calcolatori.
Un numero in complemento a 2 si può anche calcolare come:
Dove a significa che cambio tutti i bit di a e poi aggiungo 1
a
a
0 0 1 Æ 1 1 0 +
0 0 1 =
1 1 1
–1
–a = a +1
Questo metodo è più veloce per il calcolatore.
Per quanto riguarda la sottrazione posso utilizzare il seguente metodo:
a – b = a + (– b)= a + b +1
Ci sono anche altre notazioni, tra cui la notazione polarizzata
1 1 1 4
1 1 0 3
1 0 1 2
1 0 0 1
0 1 1 0
0 1 0 -1
0 0 1 -2
0 0 0 -3
Nell’esempio la polarizzazione o excess è 3 (perché inizio con -3)
8
L’ordinamento dei numeri è naturale e sono facilitato nella confronti.
Definisco io l’inizio della notazione
Serve nella notazione in virgola mobile
Rappresentazione numeri in virgola mobile
L’obiettivo della rappresentazione in virgola mobile (Floating Point) è quello di approssimare la
rappresentazione dei numeri reali.
I pc utilizzano la notazione scientifica: 1,2793×10-6 Ö 0,0000012793
Le cifre significative si chiamano Mantissa.
Rappresentazione di riferimento per i numeri reali:
± 1,xxxxxx × 2yyyyyy
↓
segno
mantissa
esponente
Nella prima posizione della mantissa ho inserito 1 (questo 1 ci sarà sempre e sarà il sistema a
ricordarsi di inserirlo) per far si che ho più bit significativi dopo la virgola; la maggior precisione è
data dall’esponente. Devo tener presente che ho un numero di bit limitati.
N° di bit
1
S
Segno:
0 (+)
1 (–)
3
EXP
4
MANTISSA
rappresentato
in notazione
polarizzata
rappresentata in notazione senza segno
Esempio 1:
Dato 0,625 trasformarlo in binario
(mettiamo che l’esponente abbia notazione con polarizzazione 3)
0,625 x 2
1,25 x 2
(nel calcolo successivo non tengo conto dell’1 prima della virgola)
0,50 x 2
1,0
Il numero in binario è dato dalle cifre prima della virgola
Quindi 0,625 in binario è 0,101
(posso rappresentare solo numeri che siano somme di potenze di 2)
Rappresento nella notazione standard:
0,101 normalizzato è 1,01 × 2-1
0 0 1 0 0
1
0
0
S
EXP
MANTISSA
Esempio 2:
Dato 0,15 trasformarlo in binario
0,15 x 2
0,30 x 2
0,60 x 2
1,2 x 2 (considero 0,2)
0,4 x 2
0,8 x 2
9
Architettura
1,6 x 2
1,2
Il numero è periodico in base 2
Il codice binario è: 0,001 0011 che normalizzato è: 1, 0011 × 2-3
(La parte periodica sarà quella scritta come mantissa)
0 0 0 0 0
0
1
1
S
EXP
MANTISSA
L’esponente è 000 perché la notazione ha polarizzazione 3.
C’è comunque approssimazione perché in realtà la rappresentazione corrisponde a: 0,1484375
Anche nel Floating Point esiste l’overflow
Ci sono anche delle rappresentazioni standard: la IEEE754
• A singola precisione (32 bit)
N° di bit 1
8
23
S EXP
MANTISSA
L’esponente ha polarizzazione 127
• Doppia precisione (64 bit)
N° di bit 1
11
52
S EXP
MANTISSA
L’esponente ha polarizzazione 1023
“Le unità logiche del pc non sanno cosa ci sia scritto nei registri, cioè se sono parole o numeri”
Oltre ai numeri dobbiamo anche rappresentare i caratteri e per questo si usa la codifica ASCII (a 8
bit). La tabella ascii ha i caratteri in ordine crescente; il numero che rappresenta la A è più piccolo
di quello della B
A < B < C < D…
Circuiti logici
Portano dei segnali a 2 stati (0 e 1)
Ingressi
(I)
I0
U0
In-1
Um-1
Uscite
(U)
Il circuito può avere 2n combinazioni di ingressi.
Si distinguono in 2 categorie:
• Combinatori – a un certo istante le uscite dipendono esclusivamente dagli ingressi; U = f (I)
• Sequenziali – hanno una memoria riguardo allo stato (S) precedente; U = f (I, S)
S0 S
I
n
Sk-1
U
m
Si dice che ha k bit di memoria
CIRCUITI COMBINATORI
La tabella di verità di un circuito ci da tutti i valori di uscita per ogni possibile ingresso.
Esempio:
Abbiamo 3 bit, quindi abbiamo 2n righe per le possibili combinazioni di ingressi (23 = 8).
10
U1 vale 0 se c’è almeno uno zero fra gli ingressi e vale 1 se tutti e tre gli ingressi sono a 1.
U0 vale 0 se tutti gli ingressi sono a zero, mentre vale 1 per tutti gli altri casi.
I2 I1 I0 U1 U0
0 0
0
0
0
0 0
1
0
1
0 1
0
0
1
0 1
1
0
1
1 0
0
0
1
1 0
1
0
1
1 1
0
0
1
1 1
1
1
1
Nei circuiti combinatori ci sono combinazioni di funzioni logiche elementari che vengono realizzate
da porte logiche; le porte logiche sono circuiti che eseguono funzioni logiche elementari
AND logico
Viene indicato con: F = A B
A
A
0
F
0
B
1
1
B
0
1
0
1
F Åvale zero se c’è almeno uno zero
0
0
0
1
OR logico
Si indica con: F = A + B
A
F
B
A
0
0
1
1
B
0
1
0
1
F
0
1
1
1
Åvale 1 se c’è almeno un 1
NOT
Si indica con: F = A (cioè negazione di A)
A
F
A
0
1
F
1
0
Combinando opportunamente queste tre funzioni logiche posso realizzare qualsiasi espressione
logica.
Esistono anche altre porte particolari:
NAND (nega un AND logico), viene indicato con: F = A ⋅ B
Il pallino dopo la porta And ha funzione di negazione
A
F
B
A
0
0
1
1
B
0
1
0
1
F
1
1
1
0
11
Architettura
Da sola, la porta NAND, costituisce un insieme completo perché posso realizzare qualsiasi funzione
in logica booleana utilizzando una serie di NAND.
Esempio:
• Per simulare un AND metto in sequenza due porte NAND
• Per simulare un OR nego gli ingressi della porta NAND
• Per simulare il NOT è sufficiente sdoppiare il segnale in arrivo in modo che entri nei due
ingressi della porta NAND.
Costruttivamente una porta NAND è una porta AND tolto un transistor. I circuiti integrati utilizzano
un insieme di porte NAND
EXOR (OR esclusivo), si indica con: F = A ⊕ B
A
F
B
A
0
0
1
1
B
0
1
0
1
F
0
1
1
0
L’EXOR
1. serve per un test di uguaglianza (se gli ingressi sono uguali l’EXOR vale 0)
2. A meno del riporto l’EXOR è la somma di 2 bit (quindi è un componente del circuito della
somma)
3. Fa il complemento comandato
Il complementatore comandato è un circuito che dato un ingresso, un’uscita e un segnale di
controllo esegue: se C (segnale di controllo) = 1 allora l’uscita è la negazione dell’ingresso,
mentre se C = 0 l’uscita è uguale all’ingresso
MULTIPLEXER
Seleziona e mette nell’uscita il valore dell’ingresso indicato dal segnale di controllo. Se il numero di
segnali di controllo è n, il numero massimo di ingressi sarà 2n.
Se ho 2 ingressi ho bisogno di 1 segnale di controllo
Se ho 4 ingressi ho bisogno di 2 segnali di controllo
Se ho 8 ingressi ho bisogno di 3 segnali di controllo
Se ho 9 ingressi ho bisogno di 4 segnali di controllo (perché con 4 segnali di controllo posso
rappresentare 24 = 16 combinazioni possibili)
I0
I!
I2
I3
F
C0
F = IC1 C0
Se C1 C0 = 00
Se C1 C0 = 01
Se C1 C0 = 10
Se C1 C0 = 11
Æ
Æ
Æ
Æ
F = I0
F = I1
F = I2
F = I3
C1
DECODER
Prende un numero binario in ingresso e attiva la linea di uscita corrispondente (al numero binario in
ingresso)
12
Se I1 I0 = 00 Æ F0 = 1, F1,2,3 = 0
Se C1 C0 = 01 Æ F0 = 0, F1 = 0, F2,3 = 0
F0
F1
F2
F3
I0
I1
Circuito per la somma di 2 numeri
Il circuito necessario per eseguire la somma a 1 bit si chiama Full Adder. Se devo sommare 2
numeri a 4 bit avrò bisogno di 4 Full Adder (1 per ogni bit)
riporti
(0)
(1)
(1)
A=
B=
S=
0
0
0
0
0
1
1
1
1
1
1
0
(3)
(3)
(6)
A
|
B
|
CIN (Carry In)
|
Full Adder
↓
↓
S
COUT (Carry Out)
Esempio: somma a 4 bit (nella tabella indico la posizione dei vari bit)
A=
a3
a2
a1 a0
B=
b3 b2 b1 b0
s2
s1 s0
S=
s3
a3
Carry out
b3
a2
s3
b2
a1
s2
b1
(non ho carry in
iniziale)
a0
s1
0
b0
s0
Lo schema usato ha un difetto di prestazioni, è un metodo lento e il carry deve avere un segnale
stabile.
Ci sono dei circuiti, i Carry Look Ahead, che sono pensati per velocizzare la somma
Il sommatore è costituito da due funzioni:
S = ( A ⊕ B ) ⊕ CIN = A ⊕ B ⊕ CIN
COUT = A ⋅ B + A ⋅ CIN + B ⋅ CIN
Il Cout viene fuori quando almeno 2 bit sono a 1
13
Architettura
Tavola di verità di COUT
A
0
0
0
0
1
1
1
1
B
0
0
1
1
0
0
1
1
CIN COUT
0
0
1
0
0
0
1
1
0
0
1
1
0
1
1
1
Å qui si verificano tutte e 3 le condizioni
SOMMA E SOTTRAZIONE (in un unico circuito)
a3
b3
a2 b2
a1
b1
a0
b0
Cin
Sottrai
Il Cin assume
il valore 1 se
il segnale
sottrai è a 1,
ciò vuol dire
che devo
eseguire la
sottrazione
Cout
s3
s2
s1
s0
È un complementatore comandato
cioè una porta EXOR.
In uscita ottengo l’ingresso negato
a seconda del segnale sottrai
(segnale che indica
se devo are la
somma o la
sottrazione)
Si ricorda che la sottrazione a – b = a + (– b)= a + b +1
Circuiti sequenziali
Hanno una memoria. Hanno un segnale di temporizzazione per la logica sequenziale.
Il segnale di temporizzazione è dato dal clock.
T
1
= frequenza
T
Se la frequenza è 1 GHz, il periodo è di 1 ns (nano secondo)
In alcuni casi può essere necessario filtrare il segnale di clock in maniera che si fermi.
Il FLIP FLOP D (la D sta per ritardo) contiene 1 bit di memoria
D
Q
segnale di clock
14
Il Flip Flop campiona il segnale di indresso D a instanti predefiniti, che sono dati dal segnale di
clock, e ne memorizza lo stato fornendo, anche, un uscita Q.
Il Flip Flop che stiamo studiando, in particolare, è il Flip Flop D Negative Edge Triggered.
Clock
D
Q
Circuiti sequenziali importanti:
• Registro (a n bit) – elemento di memoria base
• Macchina a stati finiti
Il 3-state
Il 3-State non è una funzione logica in senso proprio.
A
F
C
A
C F
1 A
0
Dove il trattino indica uno stato di alta impedenza che non fa passare il segnale elettrico
qualunque
sia A
Il 3-state varia stato a seconda del segnale di controllo C e non dipende dall’ingresso A.
Serve per il Bus.
Il Bus non può ricevere più stati di segnale contemporaneamente altrimenti il circuito si brucerebbe.
Il 3-state si trova tra la “periferica” (memoria, cpu, …) e il bus in modo da far passare un solo
segnale elettrico alla volta.
Ritornando ai registri
La realizzazione di un registro (unità di memoria) a 4 bit utilizza 4 flip-flop.
A ogni colpo di clock (CK) il flip-flop memorizza un nuovo valore ma dimentica il valore
precedente.
Write (WR) è un segnale che dice quando scrivere, però ho anche bisogno di un segnale di
abilitazione (enable – EN) perché non tutti i registri devono memorizzare quel determinato valore
nello stesso tempo. Avrò anche un segnale di read (RD – lettura) che mi dice quale registro è attivo
per la lettura. Il disegno sulla pagina successiva rappresenta in modo completo quello che ho appena
detto.
15
Architettura
D3
d2
d1
d0
CK
WR
EN
q3
q2
q1
q0
RD
MACCHINE A STATI FINITI (FSM)
È un circuito che serve per realizzare la logica di controllo.
Lo schema qui sotto rappresenta la Macchina di Moore.
n
Funzione di stato
futuro
k
I
Bit di stato
(insieme di
flip-flop)
Funzione di
uscite
k
m
U
k
k
Dipende anche dallo stato presente che arriva dai bit di stato
Non è l’unico modello di macchina a stati finiti; c’è anche la Macchina di Mealy che ha un
collegamento in più che dagli ingressi I va direttamente alla funzione di uscita e di conseguenza
l’uscita dipende anche dall’ingresso corrente e non solo dai bit di stato.
Una macchina a stati finiti può essere anche costituita solamente da un flip-flop e come logica di
stato futuro avere una porta NAND; questa macchina a stati finiti ha 1 bit di stato. In questo caso se
l’ingresso I vale 0 ha un uscita bloccata a 1, mentre se I vale 1 mi genera un segnale periodico che
vale la metà rispetto a al clock, se il clock è di 1 GHz il segnale in uscita sarà di 500 MHz, quindi
dimezza la velocità del clock.
I PALLOGRAMMI mi aiutano a descrivere una macchina a stati finiti a seconda dello stato che
assume.
Se ho n bit ho 2n stati possibili.
I=0
“0”
0
16
I=1
I=1
“1”
1
I=1
Se sono nello stato 0 e I vale 1 al colpo di clock si dovrà passare allo stato 1 e lo stesso vale se sono
nello stato 0 e I = 1. Mentre se sono nello stato 1 torno allo stato 0 solo se al colpo di clock I = 1.
La macchina di Moore, ad esempio, ha 4 stati.
Architettura MIPS e Assembler
CPU
Memoria
BUS
Periferiche
k
i fili
Register file
Registro istruzione (non è possibile
accedervi in fase di programmazione)
Bit dentro al registro
0
31
0
N° di
registri
31
La MIPS progetta la CPU e vende la licenza di costruzione.
La CPU MIPS di riferimento del corso è la R2000/3000 a 32 bit che è di tipo RISC cioè con un set
di istruzioni ridotte. I 32 bit della CPU indicano la parola del calcolatore
Istruzione ADD
L’istruzione ADD esegue la somma del contenuto di due registri e ne memorizza il risultato in un
3° registro
Per convenzione i registri si indicano con $ seguito dal numero del registro tenendo presente che si
inizia a contare da 0.
Sintassi dell’istruzione:
add $13, $14, $15
Registro dove viene
memorizzato il
risultato
1° operando
2° operando
Formato dell’istruzione in linguaggio macchina
17
Architettura
L’istruzione, in linguaggio macchina, viene rappresentata su 32 bit. I 6 bit più significativi (da 26 a
31) rappresentano il codice operativo (operative code) dell’istruzione da eseguire (nel nostro caso
sono 000000)
Per specificare gli operandi servono 5 bit perché 25=32.
Il formato dell’istruzione è di tipo R
15 bit
31 30 29 28 27 26
0 0 0 0 0 0
2° operando
In realtà il codice
operativo della add
è uguale anche a
quello di altre
operazioni
1° operando
risultato
3 gruppi di bit per
indicare gli operandi e
dove salvare il risultato
SHAMT
FUNCT
Shift Amount
5 bit
Function
Sono i 6 bit meno
significativi
Quando l’operative code ha 6 zeri entrano in gioco i 6 bit meno significativi, cioè la function, che è
l’estensione del codice operativo.
Per l’add, la function è 0x20 (in esadecimale), in binario è: 00100000; sono 8 bit ma ne abbiamo
solo 6 a disposizione quindi eliminiamo i primi 2, quindi ottengo: 100000.
L’istruzione sub (sottrazione) ha codice operativo 0x22 cioè 100010 in binario.
La memoria 2
8 bit
232
riga = parola di memoria, cella, locazione di memoria.
Ci sono 232 locazioni di memoria possibili, il che vorrebbe dire
che noi teoricamente possiamo avere 4GB di memoria RAM
disponibile. Noi pensiamo che la nostra macchina virtuale abbia
sempre 4GB di memoria
Dentro al circuito di memoria c’è un decodificatore che riceve 32 bit che specificano una delle 232
possibili locazioni di memoria ed ha anche 32 bit di uscita.
Le informazioni arrivano dal BUS.
Ricordo che il bus è diviso in 3 sezioni: il Bus dati, il Bus indirizzi (per il MIPS ha 32 bit) e il bus di
controllo.
Si utilizzano più parole di memoria per un dato che occupa più di 8 bit; posso spostare 4 parole di
memoria in contemporanea purché siano adiacenti fra loro cioè con indirizzi vicini.
Dalla CPU escono i 32 bit del bus indirizzi e arrivano al decodificatore. Dal decodificatore si attiva
un solo filo riferito a una sola parola di memoria. Il contenuto di 8 bit della parola di memoria viene
trasferito sul bus dati che li porta alla CPU. Questa è una lettura in memoria.
18
Memoria
Bus indirizzi
Bus dati
Bus controllo
Il tratto rosso indica che la CPU fornisce un indirizzo di memoria, mentre il tratto blu indica che
dalla memoria arrivano alla CPU i dati.
Ogni trasferimento parte con un dato che è l’indirizzo della memoria che proviene dalla CPU.
Attraverso il bus indirizzi arriva al decodificatore, presente nella memoria, che riconosce
l’informazione e attiva un solo filo di uscita che va nella memoria vera e propria.
Bistabile Æ circuito con 2 stati stabili, sono sempre gli stessi (flip-flop). La memoria non è fatta
con bistabili perché costerebbe troppo.
Interruttore comandato
D
D
Dal decoder
C
Q
Q
Interruttore comandato
Read / write
Nella scrittura in memoria solo una cella di memoria è coinvolta e devo fare in modo che i dati sul
bus interno alla memoria arrivino all’ingresso del flip-flop per scrivere i dati.
Non posso chiudere contemporaneamente tutti gli interruttori; ci vuole un controllo C che tramite
un segnale logico dice che sono in lettura o in scrittura per far si che venga aperto/chiuso
l’interruttore corretto. Questo segnale parte dalla CPU e arriva alla memoria tramite il bus di
controllo.
Ritornando al discorso della possibilità di spostare 4 parole di memoria in contemporanea.
È possibile eseguire questa operazione solo quando è verificata una determinata condizione: “I 2 bit
meno significativi dell’indirizzo devono essere 0”.
Quando questa condizione si verifica posso spostare le 4 parole di memoria successive a questo
indirizzo. Questo gruppetto si dice che è allineato alla parola del calcolatore (o allineato a 4 byte).
19
Architettura
Posso suddividere tutta la memoria in vari gruppetti purché la parola di memoria iniziale del
gruppetto abbia l’indirizzo che termina con due 0.
Lo schema sottostante mostra come devono essere allineate le parole di memoria per poterle
spostare tutte e 4 in contemporanea.
4
3
2
1
11
10
01
00
Assembler parte 2
Istruzione LW (load word) Æ carica un valore dalla memoria con indirizzo specifico e lo scrive in
un registro del register file.
Con questa istruzione movimento 32 bit dalla memoria cioè 4 parole di memoria
Sintassi dell’istruzione
lw $19, indirizzo
Registro del register
file
Indirizzo della
posizione di
memoria
L’istruzione sw (store word) permette di memorizzare in memoria il contenuto di un registro del
register file ed ha sintassi:
sw $19, indirizzo
Registro del register
file
Indirizzo della
posizione di
memoria
Entrambi le istruzioni lw e sw hanno formato “I” cioè Immediate e l’indirizzo è la somma di due
entità: numero + contenuto registro
La sintassi corretta e il formato sono:
lw $19, numero($15)
Registro base
Registro di
destinazione (nel
register file)
20
Spiazzamento,
immediato o offset
10 bit
31 30 29 28 27 26
1 0 0 0 1 1
| 15
Registro base
Codice operativo
della load word (in
esadecimale è
0x23)
Destinazione
0
Immediato
(ho 16 bit per memorizzarlo)
1 gruppi da 5 bit per
indicare i registri
Lo piazzamento mi fornisce una finestra di accesso a una serie di spazi di memoria quindi mi devo
solo ricordare del registro base.
Esempio:
lw $19, 1024($15)
216
2
$15
Lo spiazzamento viene convertito in un numero binario in complemento a 2 su 16 bit quindi io ho
un range di valori che è pari alla metà dello spiazzamento in su rispetto al registro base e in giù
rispetto al registro base.
Se ho offset 0 recupero il contenuto del registro base. L’offset per gli spostamenti va incrementato
ogni volta di 4 per andare alla parola di memoria successiva, ad esempio se ho offset 8 rispetto al
registro base che ho indicato vuol dire che io recupero il contenuto che sta 2 registri sopra al
registro base che ho indicato. Ricordo che l’offset può essere negativo perché nella conversione in
binario si utilizza la notazione in complemento a 2; con offset negativo recupero il contenuto di un
registro sotto al registro base (devo comunque ricordare che ho una finestra di accesso che è 216
possibili combinazioni)
Istruzioni lb e sb (load byte e store byte)
Movimento dalla (o nella) memoria 1 byte cioè una sola parola di memoria.
Le istruzioni load byte e store byte hanno un formato “I” come la load word e la store word
lb $19, indirizzo
sb $19, indirizzo
Ciclo fondamentale
Ma come fa il registro istruzioni a prendere il valore dell’istruzione e non uno a caso?
Esiste un registro che contiene l’indirizzo dell’istruzione o puntatore all’istruzione (Instruction
Pointer). L’Instruction pointer nella realtà viene chiamato Program Counter.
Quando ho un dato che funge da indirizzo si chiama puntatore
Il pc è in grado di eseguire solamente il ciclo fondamentale che è composto da 4 passaggi:
21
Architettura
1. REPERIMENTO DELL’ISTRUZIONE (fetch)
Tramite il bus indirizzi viene comunicato alla memoria in quale registro leggere e tramite il
bus dati arriva l’istruzione. Questa operazione è fatta dall’hardware
2. DECODIFICA (dell’istruzione)
Guardo il codice operativo e vedo cosa devo fare
3. ESECUZIONE (specifica di ciascuna istruzione)
(4.) INCREMENTO DEL PROGRAM COUNTER
(PC = PC + 4 Å tipico del MIPS perché passo alla parola di memoria successiva)
Questo incremento può essere fatto dove si vuole purché sia prima del reperimento di una
nuova istruzione. Normalmente questo incremento viene effettuato tra la fase 1 e la fase 2.
Si chiama Ciclo Fondamentale perché il pc fa sempre queste cose da quando lo si accende.
La macchina, in automatico, è in grado di eseguire una serie di istruzioni che partono da un punto
preciso della memoria e continuano in sequenza.
Struttura dei registri del MIPS 32
Il MIPS ha 32 registri suddivisi in maniera specifica. Al momento ci occupiamo dei registri da 8 a
15 e dei registri da 16 a 23
I registri da 8 a 15 sono registri temporanei e vengono indicati con la sigla $t seguita da un numero
progressivo che va da 0 a 7
Numero
registro
Nome
registro
8
9
10
11
12
13
14
15
$t0
$t1
$t2
$t3
$t4
$t5
$t6
$t7
I registri da 16 a 23 vengono denominati saved temporary e si indicano con $s seguito da un numero
progressivo da 0 a 7
Numero
registro
Nome
registro
16
17
18
19
20
21
22
23
$s0
$s1
$s2
$s3
$s4
$s5
$s6
$s7
Gli altri registri disponibili vengono utilizzati in fase di scrittura del codice assembly per permettere
delle azioni da parte dell’utente come ad esempio l’input e l’output di dati.
Esempio completo di una istruzione di somma
(sintassi, formato e conversione in hex)
Scrivere l’istruzione che fa la somma di 3 e 2.
$t0 := 3
$t1 := 2
$t2 := risultato
22
La sintassi dell’istruzione è:
add $t2, $t0, $t1
Il formato dell’istruzione è: (si ricorda che la add ha formato R)
0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 1 0 1 0 1 0 0 0 0 0 0 1 0 0 0 0 0
$t0
(registro 8)
Operative code
$t1
(registro 9)
$t2
(registro 10)
Function code
Shift Amount (in questo caso è
32(10))
Per ottenere la rappresentazione esadecimale raggruppo ogni 4 bit e eseguo la rispettiva conversione
in decimale di ogni gruppetto:
0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 1 0 1 0 1 0 0 0 0 0 0 1 0 0 0 0 0
0
1
0
9
5
0
2
0
Il esadecimale è: 0109520(16) oppure è anche possibile scrivere 0x0109520
Assembler parte 3
Se devo sommare il valore di un registro con una costante che non è memorizzata in nessun registro
uso l’istruzione addi (add immediate)
La sintassi è la seguente:
addi $t0, $t1, 100
Il formato dell’istruzione è “I” perché si utilizza l’immediato su 16 bit per passare la costante
0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0
Operative code
(in questo caso è
8 in decimale)
$t0
1° registro
$t1
2° registro
Costante (in binario su 16 bit)
Devo trasformare 100 in binario:
100 = 64 + 32 + 4
= 26 + 25 + 22
Nelle posizioni indicate dall’esponente delle
potenze di 2 si trova il bit = 1.
Flusso di istruzioni
Devo inserire, io programmatore, le istruzioni in memoria in modo continuo cosicché la CPU possa
eseguirne una dietro l’altra per ottenere il cosiddetto flusso di istruzioni.
Ma oggi come oggi non è possibile avere una sequenza di istruzioni perché, ad esempio, se devo
eseguire una divisione devo eseguire azioni diverse (che non sono in sequenza) a seconda che il
divisore sia 0 o no. Questa è chiamata alterazione del flusso.
23
Architettura
ALTERAZIONE DEL FLUSSO
L’alterazione del flusso avviene in fase di esecuzione del programma e non quando viene
programmato.
Le istruzioni in sequenza del programma vengono eseguite sino a quando non si trova l’istruzione
che implica la verifica di una condizione (ad esempio confrontare se sono uguali due valori), questa
scelta (cioè le verifica della condizione) viene eseguita on-line cioè quando il programma è in fase
di esecuzione. Il programmatore nella fase off-line (quando scrive il codice) deve assicurarsi che il
programma venga caricato correttamente e che le istruzioni da eseguire siano posizionate
correttamente.
Ricorda:
La sintassi in binario di una funzione assembler ha diversi formati:
Formato R – con 3 registri (esempio: add)
Formato I – con 2 registri e un immediato (esempio addi)
CONDIZIONE DI UGUAGLIANZA
beq (branch on equal)
Se la condizione è verificata si fanno determinate istruzioni, altrimenti si continua il flusso
Ramo di istruzioni B
Se la condizione è
verificata
Ramo di istruzioni A
Punto di snodo
(verifico la condizione)
Se la condizione è verificata eseguo il ramo di istruzioni B, altrimenti eseguo il ramo di istruzioni A
Per indicare a quale registro devo andare quando è verificata la condizione devo indicare alla
funzione beq un target address. Il formato dell’istruzione è un formato I dove ho due registri e un
immediato che in questo caso è il target address.
Beq $21, $23, target_address
Per indicare il target address bisogna stabilire l’offset.
Devo arrivare qua
A
offset
Punto di snodo
Se la condizione è verificata il pc calcola l’indirizzo in base al program counter a all’immediato che
abbiamo inserito nella funzione beq. Il target address verrà poi scritto nel program counter per far si
che la prossima istruzione sia quella del ramo di istruzioni corretto.
24
Beq $21, $23, <qui scrivo l’immediato (o offset)>
Nella funzione beq scriviamo solamente l’offset, sarà il pc in fase di esecuzione che calcola
realmente il target address.
Come faccio a sapere che offset devo scrivere?
Devo sapere quanto è lunga l’occupazione in memoria del ramo di istruzioni A che devo saltare.
Siccome sono io programmatore che sto scrivendo il programma conosco quante istruzioni ci sono
nel ramo A, le moltiplico per 4 e ottengo l’offset
Il salto che fa l’istruzione beq è un salto condizionato e relativo.
È un salto condizionato perché dipende da una condizione.
È un salto relativo perché la finestra di possibili atterraggi (dato dal fatto che l’immediato è un
numero su 16 bit in complemento a 2) si sposta in base al program counter
Un trucco per l’immediato è considerare che oltre ai 16 bit ho altri 2 bit che sono sempre 00 perché
so che i blocchi di istruzioni vicine hanno sempre i 2 bit meno significativi uguali a 0, come quando
devo spostare 4 registri contemporaneamente.
Esempi di altre istruzioni di confronto:
bne (branch on not equal) restituisce true se i 2 registri non sono uguali.
Slt (set less than) [è un’istruzione di tipo R con codice operativo = 0 e 3 registri)
slt $1, $2, $3
Se $3 < $2 scrive in $1 il valore 1, altrimenti $1 = 0
Devo combinare più istruzioni per verificare se il contenuto è maggiore o minore di un altro
registro
Il sistema con un Istruction Set Architechture di tipo RISC, cioè ridotto, permette di eseguire
istruzioni semplici molto più velocemente di un sistema con ISA ampio. Il tipo RISC è quello più
usato oggi
Ritornano a beq alla fine delle istruzioni del ramo A devo saltare il ramo B perché non lo devo
eseguire altrimenti è stato inutile il fatto di verificare la condizione. Questo è un salto
incondizionato.
Questo salto viene fatto con l’istruzione jump che ha un formato e una sintassi particolare:
j target address
25
Operative code
(6 bit)
0
Target address su 26 bit
25
Architettura
Siccome è un salto assoluto devo specificare tutti e 32 i bit dell’indirizzo pur avendone a
disposizione 26; specifico i 26 bit dell’immediato, i 4 bit più significativi vengono dai 4 bit più
significativi del program counter e i due bit meno significativi sono sempre 0 in modo che sia
allineato alla parola.
31
30
29
28 27
2 1
Address su 26 bit
0
0 0
Questi 2 bit sono sempre
0 in modo che ci sia
l’allineamento alla
parola di memoria
Questi sono i 4 bit
più significativi
del program
counter
La memoria di 4GB (teorica a nostra disposizione) è divisa in 16 finestre fisse da 256MB ciascuna.
Con l’istruzione jump posso saltare solo nella finestra fissa corrente e non posso cambiare finestra.
Se devo cambiare finestra fissa uso l’istruzione jr (jump register) a cui passo l’indirizzo a 32 bit
del registro: jr $30
Mappa in memoria di beq
50444
1000 • 4
(offset)
Per evitare che vengano
eseguite le istruzioni del
ramo B anche se la
condizione è falsa
posiziono qui un salto
incondizionato
B
400 • 4
(offset)
Se è vera
46444
46440 Æ
44844
A
Se la condizione
non è verifica
vado in sequenza
Istruzione di snodo
100 • 4
(offset)
44444
Serie di istruzioni che
vengono eseguite in
sequenza
Indirizzo
dell’istruzione
26
L’offset è dato dal numero
di istruzioni per 4
Supponiamo che l’indirizzo di inizio sia 44444. Se l’istruzione di snodo si trova a 100 istruzioni di
distanza dall’inizio si troverà nel registro con indirizzo 44444 + (100 • 4).
Se il ramo A è lungo 400 istruzioni terminerà, quindi, all’indirizzo 46444 e di conseguenza
l’istruzione del jump incondizionato si troverà nella parola di memoria precedente cioè all’indirizzo
46440.
Se il ramo B è lungo 1000 istruzioni avrà termine all’indirizzo 50444.
Il programma assemblatore permette di evitare di eseguire questi calcoli utilizzando delle etichette
(label). Ogni nome di etichetta ha un corrispettivo indirizzo di memoria.
Ad esempio chiamo pippo l’indirizzo dell’inizio del ramo B e chiamo pluto il punto di termine del
ramo B inserisco queste etichette al posto del target address. Sarà l’assemblatore che creerà i
riferimenti agli indirizzi e calcolerà il target address da inserire al posto dell’etichetta.
A
B
Add
......
......
......
......
......
......
beq $x, $y, pippo
......
......
......
......
......
j pluto
pippo:
......
......
......
......
......
......
pluto:
......
......
......
......
# inizio del programma
# uso dell’etichetta
# il carattere # indica il commento a
# riga singola)
# ultima istruzione del ramo A
# dichiarazione dell’etichetta
# ultima istruzione del ramo B
#dichiarazione dell’etichetta
# fine programma
Se devo verificare che un numero è maggiore, minore o uguale a 0 devo verificare i contenuti di due
registri:
y Posso usare un registro fisso a 0
y Oppure cancellare il contenuto di un registro
Nell’architettura MIPS 32 c’è un registro fisso a 0 che è il registro $zero
Il circuito di questo registro è a massa in modo che sia impossibile memorizzare qualsiasi valore in
questo registro e quando lo leggo ottengo sempre il valore 0.
Pseudoistruzioni
27
Architettura
Le pseudoistruzioni sono istruzioni lecite per il programma assemblatore che si possono tradurre
con una o più istruzioni base del linguaggio assembler
Ad esempio:
li $22, 47
Questa pseudoistruzioni carica il numero 47 nel registro 22. Il numero da caricare non può essere
più grande di quelli consentiti con 16 bit.
Un’altra pseudoistruzioni è la move che sposta il contenuto di un registro in un altro, ma sena
cancellare il contenuto del registro di partenza
move $5, $13
Convenzioni di uso della memoria
Per Unix e MIPS 32
Siamo sempre nel caso teorico di aver a disposizione 4GB di memoria.
Questa è in generale la suddivisione della memoria
0xFFFF FFFF
Questa è la parte riservata ai
programmi del sistema
operativo (metà della memoria
disponibile)
STACK
0x7FFF FFFF
Qui ci sono
i dati
0x1000 0000
TEXT
0x0040 0000
0x0000 0000
HEAP
Zona dei dati dinamici. Dati
che nascono e “muoiono”
durante l’esecuzione del
programma
0x1000 8000
Dati statici. Sono i dati che
esistono quando il programma
parte e smettono di esistere
quando viene terminato il
programma
Spazio riservato
Nella zona dei dati dinamici i
dati della parte Heap vengono
memorizzati da un indirizzo più
basso verso un indirizzo più alto
mentre i dati della parte stack
vengono memorizzati dall’alto
verso il basso
28
Dedicata a contenere i programmi che creeremo noi,
cioè contiene l’assemblato in linguaggio macchina.
Il programma assembler pensa che ogni volta che
eseguiamo il nostro programma sia situato in questa
zona di memoria.
I programmi non possono superare il numero di
istruzioni che stanno tra i due indirizzi di memoria di
limite di questa zona.
Le variabili esistono solo dopo che esiste lo spazio in memoria ad esse dedicato.
C’è un continuo traffico dalla memoria ai registri della CPU. Questo processo si chiama splling dei
registri o allocazione dei registri in memoria.
Implementazione hardware delle istruzioni macchina
Ripasso delle istruzioni base che analizzeremo
Queste sono le istruzioni che ogni architettura deve implementare:
y Load Word lw rt, offset(rs)
[rs] + offset
rt
origine
destinazione
Formato dell’istruzione
y
0x23
rs
rt
offset
6 bit
5
5
16
Store Word
sw rt, offset(rs)
rt
[rs]+offset
origine
destinazione
Formato dell’istruzione
y
0x2A
rs
rt
offset
6 bit
5
5
16
ADD
SUB
AND
OR
add rd, rs, rt
sub rd, rs, rt
and rd, rs, rt
or rd, rs, rt
Equivalgono tutti alla scrittura:
rs [operazione] rt Æ rd
0
rs
rt
rd
0
funct
6 bit
5
5
5
5
6
Add e sub non sono le sole istruzioni che fanno soma e sottrazione.
Queste istruzioni settano i condition code cioè sono dei codici che
Indicano se si sono verificate particolari condizioni come ad esempio
l’overflow.
y
add
sub
and
or
0x20
0x22
0x24
0x25
Set Less Than
slt rd, rs, rt
Se
rs < rt allora rd = 1
altrimenti
rd = 0
0
rs
rt
rd
0
0x2A
6 bit
5
5
5
5
6
29
Architettura
Il formato dell’istruzione è uguale a quello delle operazioni aritmetiche suggerendoci che è
t x i implementare l’istruzione slt con funzioni aritmetiche semplici
y
di
Branch On Equal
beq rs, rt, <label>
Se
rs = rt allora PC [Program Counter] = PC + offset * 4 + 4
altrimenti
PC = PC + 4
Si incrementa di 4 perché in memoria si può accedere solo a blocchi di 4 e quindi tutte le
istruzioni formate da 32 bit sono allineate alla parola di memoria cioè hanno i due bit meno
significativi = 00
y
4
rs
rt
offset
6 bit
5
5
16
JUMP j <label>
PC = PC31 ÷ 28 ||| offset * 4
La formula scritta qui sopra indica che prendo i 4 bit più significativi del program counter e
li concateno con l’offset moltiplicato per 4
2
Offset
6 bit
26
Vogliamo costruire una “macchina” che esegue queste operazioni
CPU
Unità operativa (o
Datapath)
Registri
ALU
Read
Write
Address
Comandi
Istruzione
Condizioni
e eccezioni
Dati
MEMORIA
La ALU deve saper fare
y Somma
y Sottrazione
y And
y Or
y Slt
y Test di uguaglianza
y Restituire condition codes ad esempio per l’overflow
30
Unità di
controllo
Macchina
a stati finiti
La ALU concettualmente è un insieme di tante piccole ALU a 1 bit in modo da ottenere 32 bit
(quindi ci sono 32 ALU a 1 bit)
Condition
codes
ALU31
ALU30
ALU0
ALU1
Comandi
Di tutte queste ALU la prima e l’ultima hanno una struttura lievemente differente.
Tutte le ALU a un bit possiedono le stesse identiche funzioni che vengono richiamate tramite il
codice operativo che agisce come segnale di selezione su un multiplexer.
a
b
F1
a
b
a
F2
b
F(N)
Operative
code
result
Vediamo ora come sono fatte le ALU a 1 bit che stanno tra la 1 e la 30 (L’indice i usato nello
schema si riferisce al numero della ALU a 1 bit che vogliamo prendere in considerazione purché sia
nel range che abbiamo detto sopra)
bi sub
a
b
a
b
CIN
COUT
a
i
dalla
verso
ALU
i+1
Full Adder
ALU
i-1
OR
AND
0 (zero)
3
2
1
0
Operative
code
resi
Operative code
00
01
10
11
funzione
AND
OR
somma / sottrazione (a seconda del segnale sub)
slt
Il 3° ingresso del multiplexer mi da sempre 0 perché serve per l’istruzione slt.
31
Architettura
Vediamo ora come è fatta la ALU0 (i = 0)
sub
bi
COUT
verso
ALU
2
a0
b0
ai
a0
b0
CIN
AND
OR
Full Adder
less
3
2
1
0
Operative
code
res0
Per l’istruzione slt
prendo rs e sottraggo rt
Il segnale less è 1 se rs
< rt altrimenti vale 0
Vediamo ora come è fatta la ALU31 (i = 31)
b31 sub
CIN
a31
overflow
3
COUT
2
b31
OR
Full Adder
0 (zero)
a31
less
1
a31
b31
AND
0
Operative
code
res31
Se CIN ≠ COUT allora
c’è overflow
Perché il bit più significativo mi dice il segno
(1 se negativo e 0 se positivo). Questo segnale
viene riportato sul 3° ingresso del multiplexer
della ALU0
Abbiamo così implementato una ALU che fa
y somma
y sottrazione
y and
y or
y slt (attraverso la sottrazione quindi con segnale sub = 1 e segnale less sul 3° ingresso del
multiplexer della ALU0)
y segnale di overflow
32
y
Test di uguaglianza
res0
Segnale zero
NOR
res31
Se tutti i risultati sono zero ottengo il segnale zero che mi dice che i numeri sono uguali
BARREL SHIFTER
È un circuito che permette di eseguire lo shift (spostamento) dei bit di 1, 2 , 3, (…) bit. Viene usato
durante la moltiplicazione
Comando
Comando
In questo punto avrò eseguito lo shift di 2 posizioni di 4 bit
Schema definitivo della nostra ALU
A
B
32 bit
32 bit
zero
sub
overflow
Vanno all’unità
di controllo
2 bit
Operative
code
Arrivano
dall’unità di
controllo
32 bit
OUT
Unità Operativa (DataPath) multiciclo
L’esecuzione di una istruzione richiede più di un ciclo di clock.
Il ciclo di clock è breve per evitare di perdere tempo nelle istruzioni più corte a discapito della
velocità per le istruzioni più lunghe.
Ciclo fondamentale
y Fetch (lettura in memoria)
y Decodifica
33
Architettura
y
Execute (l’esecuzione può richiedere anche più cicli)
o Completamento / accesso alla memoria (ad esempio quando faccio load word e store
word)
o Completamento 2 (per istruzioni molto lunghe)
Realizzeremo ora lo schema di un datapath multiciclo (per ovvi motivi si farà riferimento agli
schemi riportati nell’Appendice 1 [– Datapath] di questo quaderno virtuale)
Commento allo Schema 1 – ALU e registri
La parte principale dell’unità operativa della CPU è composta dall’unità aritmetico logica ALU e
dai registri in cui posso scrivere e da cui posso leggere dei dati.
Come abbiamo già detto la ALU ha 2 ingressi, un uscita e può inviare dei segnali di condizione
all’unità di controllo.
A ogni ingresso della ALU occorre inserire un multiplexer per la selezione corretta dei segnali
riguardanti le operazioni che vanno eseguite, ricordo che la ALU esegue anche l’incremento del
Program Counter oltre alle istruzioni che programmiamo noi. L’uscita della ALU viene
memorizzata in un registro temporaneo, ALUout; L’uscita dell’ALUout va al primo ingresso di un
multiplexer posizionato prima dei registri per una eventuale scrittura del risultato (il motivo perché
è stato posizionato qui un multiplexer sarà chiarito più avanti nella spiegazione).
Naturalmente tutti i fili, che nello schema sono rappresentati con una linea, sono a 32 bit.
L’uscita del multiplexer (che ricordo è posizionato prima dei registri) è usata come ingresso dei
registri per i dati. I registri hanno due uscite che vanno separatamente in due registri temporanei A e
B che sono collegati ai multiplexer degli ingressi della ALU.
Commento allo Schema 2 – trasferimento dati da e verso la memoria
Complichiamo ora lo schema 1 aggiungendo i collegamenti per effettuare le load word e le store
word ovvero per effettuare un accesso in memoria.
Iniziamo col derivare il fascio di fili che esce dall’ALUout e lo portiamo come ingresso in un
multiplexer, l’uscita di questo multiplexer, che chiamo IndMem, corrisponde all’indirizzo di
memoria a cui devo accedere e sarà quello che verrà trasferito sul bus indirizzi.
Come secondo passaggio faccio una derivazione sul filo che esce dal registro temporaneo B e lo
chiamo MemDataIn che porterà i dati in memoria (ad esempio per le store word), naturalmente
questi dati non necessitano di passare attraverso la ALU.
Collego, ora, un registro temporaneo, denominato MDR (Memory Data Register), al secondo
ingresso del multiplexer situato prima dei registri; l’ingresso del MDR è un filo proveniente dalla
memoria, che chiamo MemDataOut e trasporta i dati provenienti dalla memoria verso i registri
(esempio load word).
Con questi collegamenti abbiamo così aggiunto la possibilità di leggere / scrivere la memoria.
Commento allo Schema 3 – Caricamento e utilizzo dell’istruzione
Ora che posso leggere e scrivere la memoria non resta che recuperare l’istruzione che devo
eseguire. Per far questo mi occorre l’Instruction Register (IR) che ha come ingresso una derivazione
del filo MemDataOut. Ricordo che i fili rappresentano fasci di 32 fili perché ho istruzioni a 32 bit.
Dall’IR escono 3 fasci da 5 fili (quindi 5 bit) che vanno nei registri. Questi fili sono RD, RS e RT e
mi servono per selezionare il registro da cui devo prendere i dati e scrivere il risultato. Ricordo che
RD è il registro in cui scrivo il risultato, RS è il registro che fa da primo operatore il quale inserirà i
dati nel registro temporaneo A, mentre RD “butta” la sua uscita nel registro B.
Ci sono altri due fili che escono dall’IR e sono chiamati offset e servono per l’offset a 16 bit (quindi
nelle istruzioni che prevedono l’immediato) dove questi 16 bit vengono sommati, oppure
moltiplicati per 4 e sommati al contenuto di un registro per dare origine a un identificativo di
34
memoria e l’offset a 26 bit (utilizzato nelle istruzioni jump) con cui non devo eseguire nessuna
operazione matematica.
Naturalmente l’IR comunica con la logica di controllo.
Nota:
ALUout, A, B, MDR sono registri di servizio (temporanei) e non importa che abbiamo dati
stabili.
L’Instruction Register va scritto alla fine del fetch. Il Program Counter va aggiornato in
momenti precisi in modo da garantire che abbia un contenuto corretto.
Commento allo Schema 4 – Program Counter
Adesso non resta che aggiungere allo schema la parte necessaria per gestire il program counter dove
memorizzo l’indirizzo dell’istruzione da eseguire.
Per prima cosa posizioniamo un rettangolo che rappresenta il Program counter (PC) al cui ingresso
si trova l’uscita di un multiplexer a 3 ingressi. Di questo multiplexer un ingresso deriva da una
derivazione del filo che dalla ALU entra nel registro ALUout, il secondo ingresso è dato da una
derivazione del filo che esce dal registro ALUout (posso prendere i due ingressi indifferentemente);
il terzo ingresso del multiplexer mi arriva dal filo denominato offset a 26 bit il quale viene shiftato
di 2 posizioni (indicato con un blocco con scritto <<) al quale vengono concatenati i primi 6 bit che
arrivano dall’uscita del program counter. L’uscita del program counter viene anche derivata
collegandola al secondo ingresso del multiplexer che si trova sull’ingresso A della ALU
Il secondo ingresso del multiplexer situato sull’entrata B della ALU ha sempre valore 4 perché mi
permette di incrementare il program counter.
Il filo offset a 16 bit che esce dall’IR entra in una “scatola” chiamata SEXT (sign extension) dove
posso ottenere un allungamento del numero di bit, in questo caso passo da 4 a 8 bit mantenendo
inalterato il segno. Il modo con cui viene eseguita questa operazione consiste nel replicare il bit di
segno sui rimanenti bit a disposizione. Se ho un numero a 4 bit e lo voglio portare a 8 bit replico il
bit di segno (del numero a 4 bit) sui 4 bit rimanenti per formare il numero a 8 bit. In questo modo il
valore che quella configurazione di bit possiede rimane inalterato.
L’uscita del SEXT la porto direttamente al 4° ingresso del multiplexer situato sull’ingresso B della
ALU; da questo filo faccio una derivazione in un altro circuito che sullo schema indico con << 2
che esegue un doppio shift a destra aggiungendo due zeri in modo da moltiplicare l’indirizzo per 4.
L’uscita di questo circuito la porto al 3° ingresso del multiplexer situato sull’ingresso B della ALU.
In fine devo aggiungere un filo che dall’uscita del Program Counter mi porta al multiplexer che ho
posizionato per scegliere quale indirizzo devo inserire sul bus indirizzi.
Commento allo Schema 5 – Segnali di controllo
I segnali di controllo arrivano dalla logica di controllo.
Qui di seguito elenco tutti i segnali per i multiplexer con il rispettivo significato:
MemToReg (1 bit) comanda il multiplexer situato prima dei registri e indica se devo scrivere ciò
che c’è nel filo MemDataOut nei registri o se non lo devo considerare.
ALUsrcA (1 bit)
Indica quale ingresso del multipler situato sull’ingresso A della ALU devo
portare sull’uscita
ALUsrcB (2 bit)
Indica quale ingresso del multipler situato sull’ingresso B della ALU devo
portare sull’uscita
PCsrc (2 bit)
(program counter source) indica quale ingresso del multiplexer situato prima
del program counter devo considerare
IorD (1 bit)
Indica se quello che va trasferito sul bus è un indirizzo
RegDst (1 bit)
Register Destination comanda un multiplexer situato sul filo RD prima che
arrivi ai registri. Serve nel caso stia facendo una store word perché questo
registro mi serve solo per calcolare l’indirizzo della memoria
35
Architettura
Contr. ALU (3 bit)
devo dire cosa deve fare la ALU (equivalgono ai segnali sub e operative code
illustrati precedentemente)
Segnali per la scrittura nei registri
RegWrite
mi serve per dire se devo scrivere in un registro
IRWrite
alla fine del fetch mi dice che posso scrivere sull’Instruction Register
<pc>
Segnale di scrittura del program counter (può essere scritto in maniera diretta
o in maniera condizionale [cioè quando c’è un salto condizionato])
Segnali che vanno all’unità di controllo
IR31÷ 28 IR5÷ 0
sono i bit corrispondenti al codice operativo e alla function dell’istruzione e
vanno all’unità di controllo in modo che possa inviare dei segnali corretti ai
vari multiplexer e alla ALU
Zero e Overflow
sono i segnali che indicano le condizioni / eccezioni che derivano dai calcoli.
Ad esempio Overflow indica che si è verificata una condizione di overflow
durante il calcolo
Naturalmente sulla memoria avrò dei fili di controllo denominati MemRead e MemWrite che mi
indicano se devo leggere o scrivere; avrò anche due ingressi IndMem e MemDataIn ed un’uscita
denominata MemDataOut
Schema delle condizioni stabili dei segnali ogni colpo di clock
Segnale di clock
A questo istante
abbiamo
condizioni
stabili (i registri
sono stati scritti,
…)
Esecuzione dei
comandi
Preparazione
comandi da parte
dell’unità di controllo
Un attimo prima del colpo di clock ho il PC + 4 all’ingresso del program counter. Al colpo di clock
caricherò così l’istruzione corretta. L’importante è che il program counter sia corretto prima
dell’azione di fetch
Simulatore SPIM per architettura MIPS32
SPIM è un simulatore per MIPS R2000/3000 e serve per scrivere, leggere ed eseguire programmi
assembly partendo dal codice sorgente.
Contiene un debugger e fornisce un sistema per interagire con i programmi creati.
È anche possibile usare un editor diverso per scrivere i programmi purché abbia la codifica ASCII
(esempio: Notepad). L’estensione del file sorgente deve essere .s
36
Struttura dei file .s:
Area Dati:
contiene i dati usati dal programma. Il primo indirizzo è 0x10000000. Nel codice
assembly viene identificata con .data
Area codice
Inizia con la direttiva .text e inizia dall’indirizzo di memoria 0x00400000
L’inizio del programma, in un file .s, è identificato dall’etichetta “__start:” se utilizzo il controllo
delle eccezioni (file: exceptions.s), altrimenti è dato dall’etichetta “start:”
Esempi di struttura del programma:
.globl __start
.data
.text
__start:
.globl main
.data
.text
main:
Chiamate di sistema, SYSCALLS
Le chiamate di sistema vengono utilizzate per poter interagire con lo standard input e con lo
standard output. Per utilizzare le chiamate di sistema è necessario utilizzare particolari registri e
inserirvi determinati valori. (l’elenco completo dei registri e dei codici delle chiamate di sistema è
disponibile sull’appendice A).
Il registro $v0 contiene il codice della chiamata di sistema.
I registri da $a0 a $a3 contengono i possibili argomenti utilizzati durante le chiamate di sistema.
Elenco dei codici delle syscalls:
Il risultato di una lettura dell’input, con le syscalls, viene memorizzato nel registro $v0
Per gli esempi commentati sull’uso delle chiamate di sistema si vedano gli esercizi eseguiti durante
l’esercitazione del 15/11/2006 (scaricabili dal sito avsoft)
Il menu Simulator dello SPIM permette di eseguire e controllare l’esecuzione del programma
assembly:
Clear Register
Cancella i registri
Reinitialize
Riinizializza lo SPIM portando tutti i valori a quelli di default e cancella il
programma aperto
Reload <file>
Ricarica il file .s aperto (il file viene specificato a fianco della scritta Reload)
37
Architettura
Go
Esegue il programma
Break
Termina il programma
Single Step
Esegue il programma una istruzione alla volta
Multiple Step
È possibile specificare quante istruzioni deve eseguire
(Gli strumenti di debug permettono di eseguire un programma passo a passo per verficarne la
correttezza.)
Set Value…
Permette di settare il contenuto di registri, zona dati,…
Display symbol table Stampa nella message window il valore numerico assunto dalle etichette
simboliche utilizzate, e dichiarate visibili a livello globale, nel programma
assembly
Settings…
Accede alle impostazioni dello SPIM
Alcuni consigli utili:
y Potreste trovarvi nella situazione di utilizzare le pseudo-istruzioni ma quando caricate il file
.s lo SPIM vi da errore proprio su una pseudo-istruzione. Il problema deriva dal fatto che lo
SPIM è stato impostato male. Per poter utilizzare correttamente le pseudo-istruzioni andare
in Simulator > Settings e togliere la spunta dalla casella di controllo “Bare machine” e
spuntare la casella di controllo corrispondente ad “Allow pseudo instruction”. Premere OK e
ricaricare il file.
y Se in un compitino dovete dire a che istruzione corrisponde un codice esadecimale si può
utilizzare il comando Set Value dello SPIM dando come indirizzo quello di inizio del
programma (0x00400000) e come valore il codice esadecimale dell’istruzione. Lo SPIM la
convertirà per voi.
Vi consiglio di scaricare gli esercizi fatti durante l’esercitazione del 15/11/2006 perché contengono
il codice commentato che può risultare utile.
Unità di controllo: macchina a stati finiti
Dopo aver analizzato come è costituito il datapath dobbiamo anche vedere la logica che sta dietro
l’unità di controllo, da cui provenivano molti segnali dedicati a multiplexer, alu, ecc.
L’unità di controllo non è altro che una macchina a stati finiti, e come tale rappresenterò i suoi stati
utilizzando i pallogrammi. I pallogrammi a cui farò riferimento si trovano nell’appendice 2 – FSM
Diagram.
Iniziamo la spiegazione con un breve riassunto dei vari comandi che dobbiamo gestire.
Ricordo che il datapath invia delle istruzioni all’unità di controllo (ad esempio il segnale zero che
esce dalla ALU), mentre l’unità di controllo invia dei comandi al datapath.
Riassunto dei comandi:
y Per i multiplexer
o MemToReg
o RegDst
o ALUsrcA
o ALUsrcB
o PCsrc
o IorD
y Per la memoria
o MemRead
o MemWrite
y Per i registri
38
o Irwrite
o RegWrite
o < pc >
Il segnale < pc > è composto da:
y
Il segnale Pcwrite indica che il program counter viene scritto immediatamente.
PCWriteCond indica che il segnale di scrittura è condizionato dal segnale di
istruzione, zero, che esce dalla ALU
Segnali di controllo della ALU
o ALUop (indico generalmente i segnali che controllano le operazioni che la ALU
deve eseguire)
Prima di proseguire è necessario approfondire leggermente un particolare:
La figura sottostante mostra un pezzo del datapath e precisamente la ALU e il registro temporaneo
ALUout
Durante la spiegazione ho detto che il program counter può prendere l’uscita del calcolo dalla ALU
prima che entri nel registro temporaneo oppure all’uscita dal registro temporaneo. La differenza tra
le due posizioni sta nel fatto che sono sfalsate di un ciclo di clock perché l’uscita dal registro ce l’ho
solo al colpo di clock successivo a quando ho inserito il dato. Durante la spiegazione della
macchina a stati finiti quando faccio riferimento a ALU intendo che recupero il segnale subito dopo
l’uscita dalla ALU mentre quando dico ALUout significa che recupero il segnale dopo che è stato
memorizzato nel registro temporaneo ALUout.
La macchina a stati finiti dell’unità di controllo esegue determinate operazioni ogni ciclo di clock.
Nella media una istruzione richiede tra 3 e 5 cicli di clock per essere completamente eseguita. Come
vedremo i primi 2 cicli di clock sono uguali per tutte le istruzioni (e sono anche i primi due stati del
ciclo fondamentale).
Schema del segnale di clock di riferimento:
Decode
Fetch
*0
c
*1
d
*2
e
*3
f
*4
g
Il grafico qui sopra riporta i vari cicli di clock (nominati da 1 a 5) e i vari colpi di clock (da *0 a *4)
Vediamo, ora, cosa succede ai vari cicli di clock:
39
Architettura
c IR Å Mem(PC) quello che la memoria contiene in corrispondenza del program counter
L’hardware ragiona in parallelo quindi posso eseguire più operazioni contemporaneamente e
siccome la ALU non sta facendo niente gli faccio incrementare il program counter:
PC Å PC + 4
Il program counter si aggiorna al secondo colpo di clock (*1)
Al colpo di clock iniziale (*0) il PC viene trasferito sull’address bus per accedere a un indirizzo
specifico di memoria.
Abilito Irwrite così posso memorizzare l’istruzione nell’instruction register.
d All’istante *1 l’instruction register viene inizializzato. L’unità di controllo deve leggere l’IR e
interpretare l’istruzione per cambiare lo stato della macchina a stati finiti in modo da eseguire
l’operazione corretta al ciclo di clock successivo.
Siccome anche in questo stato la ALU non fa nessun calcolo allora la uso per preparare nel registro
ALUout l’indirizzo dell’istruzione nel caso in cui si debba effettuare un salto condizionato
ALUout Å PC + offset*4 + 4
Non eseguo il + 4 perché il program counter è già stato incrementato
Il valore di ALUout per l’eventuale salto sarà disponibile al colpo di clock successivo (*2)
Cosa deve fare la ALU? – segnale ALUop
Il segnale ALUop è un insieme di 3 segnali che indicano che operazione la ALU
deve eseguire e sono comandati come segue:
Logica combinatoria per il controllo della ALU
Adesso analizziamo i cicli di clock successivi che variano a seconda dell’istruzione da eseguire.
e LW, SW (load word e store word)
ALUout Å A + offset
(perché faccio l’estensione del segno)
f LW
Leggo e bufferizzo sul registro MDR
g LW
Scrivo sul registro
Queste operazioni le eseguo in 2 passaggi di stato della FSM per questioni di tempistica legate
all’hardware.
40
Quando manipolo le istruzioni devo avere l’allineamento a 4 byte, mentre quando manipolo i dati
possono anche non essere allineati
f SW
Scrivo in memoria. Ho finito perché la store word implica solo la scrittura in memoria e
quindi ritorno al fetch
e R format instruction (istruzioni con formato R – add, sub, and, or, slt)
ALUout = Op(a, B)
Dove Op è una qualsiasi operazione
Quante somme fa la ALU?
Minimo 2, le altre dipendono dall’istruzione che sta eseguendo
f R format instruction
Salvo il risultato nel registro di destinazione indicato da rd e ritorno al fetch
e Branch (tipicamente la beq)
Va ricordato che nel secondo ciclo di clock abbiamo già calcolato la posizione del salto e
che è memorizzata nel registro ALUout
Se A = B
Altrimenti
PC Å PC + offset*4 + 4
PC Å PC + 4
In poche parole verifico se A – B = zero
Quasi alla fine del terzo ciclo di clock la ALU ha eseguito l’operazione. Se il risultato è zero
aggiorno il program counter e lo faccio attraverso il segnale PCWriteCond. Va ricordato che
la condizione zero esce direttamente dalla ALU e arriva alla FSM.
e jump
Per le istruzioni di jump concateno i bit da 31 a 28 del program counter con l’offset a 26 bit
e con due bit a zero. Questa operazione non richiede l’uso della ALU perché non devo fare
conti matematici in quanto ho già i fili che sono opportunamente collegati.
Con questo si concludono i possibili stati della macchina a stati finiti che compone l’unità di
controllo.
Riporto qui di seguito uno schema riassuntivo, semplificato, della macchina a stati finiti:
41
Architettura
Una CPU reale è molto complicata perché deve realizzare alcune centinaia di operazioni.
Abbiamo ragionato, fino adesso, su una architettura che esegue una istruzione alla volta. Con un po’
di attenzione si può realizzare il fetch durante l’esecuzione di una istruzione aritmetico – logica.
Sovrapporre l’esecuzione di più istruzioni è l’idea di base del Pipelining.
Supporto alle eccezioni / interruzioni
Adesso complichiamo sia lo schema del datapath e il pallogramma della macchina a stati finiti
dell’unità di controllo per poter effettuare dei controlli sulle eccezioni e sulle interruzioni semplici.
Le eccezioni sono dei cambiamenti del flusso normale delle istruzioni:
1. Errori
– tentativo di esecuzione di una istruzione non definita (il codice operativo
non è decodificabile)
– accesso a memoria protetta o non accessibile (posso definire aree di
memoria che non contengono istruzioni oppure può essere che non ho più
memoria disponibile)
– Divisione per zero o overflow
2. System Call – page fault (capita quando sto accedendo a un indirizzo di memoria che non
risiede sulla RAM ma risiede sulla memoria virtuale creata dal sistema
operativo sul hard disk. Se tento di accedere all’indirizzo di memoria, il
programma dovrà attendere che il sistema operativo copi l’area di memoria
virtuale sulla RAM e salvi quello che c’è sulla RAM per non avere perdite
di dati; questa operazione richiede del tempo e quindi l’esecuzione del
programma viene temporaneamente sospesa in attesa che i dati siano
disponibili sulla RAM).
3. Eventi esterni – generati da dispositivi I/O
– sensori, timer,…
I punti 1 (errori) e 2 (systemcall) sono propriamente eccezioni, mentre il punto 3 (eventi esterni)
sono interruzioni (interrupt).
Le eccezioni e gli interrupt sono gestiti sia dall’hardware che dal software.
Vediamo, ora, cosa l’hardware deve sapere fare in questi casi (eccezioni e interrupt):
• Sospendere l’esecuzione
• Salvare il Program Counter (PC), perché in molti casi dopo essere passato alla routine di
gestione delle eccezioni devo poter tornare all’istruzione che stavo eseguendo
• Salvare la causa dell’eccezione
• Effettuare un salto al gestore delle eccezioni
Una volta eseguite queste operazioni il resto della gestione delle eccezioni passa al software che
deve:
• Salvare lo stato della computazione (registri, …)
Il salvataggio dello stato dipende da vari fattori:
- salvo lo stato normalmente
- la routine di gestione delle eccezioni ha dei propri registri differenti da quelli usati dalle
applicazioni
- non devo tornare al programma perché l’errore è talmente importante che non posso
gestirlo senza interrompere il processo in esecuzione
• Gestione eccezione
• Ritorno al programma
42
Esempi:
1. interrupt dovuto a un carattere battuto sulla tastiera
Ö generare un eco (segnale che viene ripetuto)
Ö mettere il carattere nel buffer del processo in attesa
Ö ritorno ad eseguire:
- il programma interrotto
- oppure passo il carattere a un altro programma
2. Stack overflow (tentativo di accesso a un area di memoria a cui non posso accedere
Ö generare un messaggio diagnostico
Ö elimino il programma che ha causato l’errore
Ö passo il controllo a un altro programma (non ritorna all’istruzione che ha causato l’errore
perché non ha senso)
3. Interrupt da timer
è simile alla pressione di un tasto sulla tastiera, ma non ritorno al programma che era in
esecuzione ma eseguo un altro programma.
In questa fase dobbiamo supportare la parte hardware della gestione delle eccezioni. Le eccezioni
che devo gestire come base di partenza sono:
• Istruzione non definita
• Overflow aritmetico
• Interruzioni
Nell’architettura MIPS gestiamo due registri aggiuntivi nel datapath:
• EPC (Exception Program Counter) – memorizza l’indirizzo del program counter dove è stata
generata l’eccezione
• CAUSE – contiene il codice evento
Vediamo ora come si modifica lo schema del datapath (lo schema originario di riferimento è lo
schema 5 presente nell’appendice 1, lo schema modificato è nell’appendice 3 – gestione eccezioni)
1. aggiungo il registro EPC che avrà un segnale di controllo EPCwrite e l’ingresso del registro
proviene direttamente dall’uscita della ALU.
2. aggiungo un 4 ingresso al multiplexer del PC, e questo ingresso fa riferimento al filo
Exception Handler che è sempre fisso (perché costruito con fili che vanno a massa e fili che
sono sempre sotto tensione) all’indirizzo dell’exception handler
3. aggiungo il registro CAUSE che avrà un multiplexer che permette di memorizzare nel
registro il codice dell’eccezione che ha causato l’eccezione. Il multiplexer è comandato da
un segnale di controllo denominato CauseInt e il registro CAUSE è comandato da un
segnale, CauseWrite, che ne permette la scrittura.
Con queste modifiche, ora, il datapath supporta l’hardware necessario alla gestione delle
interruzioni.
Adesso bisogna modificare la logica della macchina a stati finiti dell’unità di controllo (le
modifiche sono nell’appendice 3 – gestione eccezioni)
(1) gestione istruzione indefinita:
Se l’istruzione è indefinita, cioè non so che cosa devo fare a fronte di un codice operativo non
valido, lo capisco dopo la fase di decode (quindi al 2° stato della macchina a stati finiti); quindi
dallo stato del decode faccio uscire un’altra freccia in caso di istruzione non contemplata che esegue
la gestione dell’eccezione e poi ritorna al fetch.
(2) gestione overflow
43
Architettura
La situazione di overflow è già comunicata dalla ALU attraverso il filo overflow. Questa situazione
si può verificare nelle istruzione con formato R cioè quelle di tipo aritmetico. Ci troviamo, quindi,
al 3° stato della macchina a stati finite perciò siamo nella fase di execute; se si verifica overflow
vado al gestore delle eccezioni altrimenti completo con il 4° stato della macchina a stati finiti e vado
al fetch.
(3) Interrupt hardware esterna
Questo tipo di interrupt si verifica quando dei segnali esterni (da periferiche) tentano di comunicare
con la CPU. Devo campionare questi segnali su un registro che li mantiene stabili (ricordo che
questo registro li campiona ogni colpo di clock perché ha in ingresso il segnale di clock). Eseguo
l’OR di tutti i segnali e quindi capisco se esiste interrupt (sullo schema sottostante è indicato con
∃ Int), successivo eseguo una AND tra il segnale esiste interrupt e il segnale che mi dice se gli
interrupt sono abilitati o disabilitati; il segnale di uscita dall’AND si chiama Int e mi dice se ci sono
interrupt.
Questo controllo sugli interrupt lo eseguo nella fase di fetch oppure prima della fase di fetch; se c’è
interrupt eseguo la procedura di gestione delle eccezioni altrimenti proseguo con la fase successiva
(decode,…).
Nella fase di gestione delle eccezioni disabilito gli interrupt, sarà, poi, il software a riabilitarli.
Questa soluzione non funziona se avviene un interrupt in una fase diversa dal fetch. Una possibile
soluzione è quella di salvare il Program Counter in un registro del kernel ogni volta che si verifica
una eccezione, questa fase deve essere fatta con interrupt disabilitati in modo da non aver problemi
a tornare all’istruzione che stavamo eseguendo prima dell’interrupt altrimenti rischio di eseguire un
loop infinito nella gestione delle eccezioni.
Le periferiche e gli interrupt
Fino ad ora non ci siamo mai posti come fanno i programmi a finire in memoria e cosa fanno le
periferiche. Ora accenderemo una candela su questo oscuro mondo.
Qui sotto riporto il solito schema dell’architettura di Von Neumann:
44
CPU
MEMORIA
Dispositivi
I/O
BUS
Questo schema è una semplificazione perché al giorno d’oggi il bus con cui comunicano le
periferiche è differente da quello usato dalla CPU e dalla Memoria. Questo secondo bus viene
chiamato PCI e viene visto dalla CPU come una periferica.
Le diverse architetture di gestione delle periferiche possono essere distinte in due classi:
1. Periferiche mappate in memoria (I/O memory mapped)
Le periferiche vengono viste dalla CPU come locazioni di memoria.
È da ricordare che fino ad ora abbiamo pensato di avere sempre a disposizione tutta la
memoria teorica possibile di 4 GB, ora parte degli indirizzi della memoria non vengono
riconosciuti dal decoder presente nel circuito memoria, ma attraverso il bus si propagano
alle periferiche; ogni periferica ha un indirizzo specifico e quindi ogni volta che sul bus
indirizzi ho quel determinato indirizzo sarà solo una periferica a rispondere.
2. I/O space
ho un bus indirizzi distinto e gli indirizzi servono per arrivare alle periferiche
Andiamo, ora, ad analizzare come è fatta una periferica.
Lo schema che riporto qui sotto è completo, mentre la descrizione sarà esplicata a passi successivi.
La periferica è divisa in due parti fondamentali: (1) la parte specifica della periferica, che assolve ai
compiti della periferica, ad esempio una stampante avrà dei sistemi meccanici e elettronici; (2)
l’interfaccia di comunicazione per permettere alla periferica di comunicare con la CPU.
45
Architettura
L’interfaccia di comunicazione, essenzialmente, assolve due funzioni: quella di colmare lo spazio di
memoria a cui determinati indirizzi non fanno riferimento e quella di trasferire / ricevere dati.
Diremo che la periferica è una periferica di uscita se il dato va dalla CPU alla periferica (sono
periferiche di uscita le stampanti, i monitor,…).
Diremo che la periferica è una periferica di ingresso se dalla periferica, i dati, vanno alla CPU.
Le periferiche I/O memory mapped più semplici hanno un circuito di selezione che permette di
recuperare l’indirizzo dal bus indirizzi e verificare se l’indirizzo corrisponde alla periferica;
all’interno della periferica è presente un registro dati che comunica con la parte specifica della
periferica e con il bus dati.
Per scrivere un dato nel registro dati utilizzerò una semplice store word:
sw $i, < indirizzo del registro dati della periferica specifica >
Mentre se la periferica è di ingresso devo leggere dal registro dati e lo farò con una load word.
Ricordo che stiamo analizzando le periferiche I/O memory mapped e quindi posso fare queste
semplici operazioni di lettura e scrittura.
A questo punto sorge un problema: quando effettuo il trasferimento dati dalla periferica, come
faccio a sapere se c’è un nuovo dato nel registro dati.
Il programma è molto veloce nella sua esecuzione, mentre il mondo esterno da delle risposte in
maniera molto lenta (basti pensare a quanto tempo ci mettiamo per digitare un carattere sulla
tastiera rispetto alla velocità di ciclo di clock).
Serve quindi un registro di stato (nel nostro caso ha solo 1 bit) che indica se la periferica è pronta
oppure no.
L’avanzamento del trasferimento dati e l’avanzamento del programma è condizionato dal fatto che
la periferica sia pronta oppure no. Esempio: voglio ricevere un carattere da tastiera. Non posso
effettuare immediatamente una load word, ma devo prima verificare che la periferica sia pronta.
Se è pronta prelevo il dato dal registro dati. Se non è pronta continuo a chiedermi se la periferica è
pronta fino a che non ottengo una risposta affermativa.
A questo punto entra in gioco il CICLO DI ATTESA:
È pronta la
periferica?
sì
no
Trasferimento
Questo è il ciclo di attesa tra la dinamica
veloce del programma e la dinamica lenta
del mondo esterno.
46
lw $j, indirizzo reg di stato
…………
…………
…………
…………
Branch (se non è pronta)
Se è pronta
Fase di MASCHERAMENTO
Avrò il registro di stato nel registro j.
Azzero un registro, gli carico 1
nell’ultimo bit (il meno significativo).
Faccio un and fra il registro j e l’altro
registro. Alla fine avrò un registro k
che avrà 32 zeri e un 1 oppure 32 zeri
in base allo stato della periferica.
In questo modo ho mascherato i bit
che non mi servono per vedere lo stato
della periferica.
Questa tecnica di controllo dello stato si chiama CONTROLLO DI PROGRAMMA e il
trasferimento è sincrono perché è il programma che interpreta se la periferica è pronta o no
attraverso il ciclo di attesa.
Nel momento in cui faccio il trasferimento la periferica deve tornare nello stato non pronto, in altre
parole quando faccio la lw deve esserci il reset dello stato.
Ma che criteri utilizzo per la valutazione delle tecniche di accesso alle periferiche:
1. Banda passante
rappresenta la quantità di dati trasferiti per unità i tempo.
In questo caso 1 KB è 103 byte (1000), mentre in tutti gli altri casi 1 KB = 210 byte (1024)
2. Latenza
è l’intervallo di tempo tra quando il dato è pronto e il momento in cui faccio il trasferimento
Vediamo di capire che aspettative, in base a questi due criteri, ho rispetto al Controllo di
Programma:
Nel nostro, semplice, caso c’è poco tempo da aspettare (bassa latenza) e la banda passante è ampia.
Ma dove sono gli svantaggi? Lo svantaggio è dato dal fatto che il ciclo di attesa è composto da
istruzioni e quindi non posso fare altro finché non ho finito il ciclo di attesa. Questo ciclo di attesa
viene anche definito BUSY WAIT.
POLLING
Indica il fatto che “ogni tanto” vado a vedere se la periferica è pronta. Questo “ogni
tanto” lo posso anche fare con il controllo di programma.
Ribadisco il fatto che il polling indica che periodicamente vado a controllare le
periferiche; ad esempio se inserisco accessi alle periferiche sparsi in un programma
e questo programma lo continuo a eseguire ottengo lo stesso un accesso
temporizzato alle periferiche.
A questo punto bisogna trovare una soluzione più efficiente per risolvere i problemi di attesa dovuta
al Busy Wait.
La soluzione ci viene direttamente dalla gestione delle eccezioni. Il programma non va a vedere se
la periferica è pronta. Ma è la periferica che in modo asincrono comunica alla CPU una richiesta di
interruzione.
Quindi la periferica comunica, anche, con il bus di controllo con un filo denominato IntReq che ha
la funzione di chiedere una richiesta di interruzione.
Vediamo, ora, un esempio di ciò che succede:
Gestore delle eccezioni
Arriva la richiesta di interruzione. Il PC è già
impostato sull’istruzione successiva
Sto eseguendo queste
istruzioni
47
Architettura
Quando arriva l’Interrupt Request si ha una alterazione del flusso (non è un salto).
L’indirizzo del gestore delle eccezioni [che è definito dal costruttore della CPU perché è sempre
impostato al quel valore (utilizzando fili a massa, …) e che sta nell’unità di controllo] viene messo
nel Program Counter.
Per il momento disabilito le interrupt mentre sono nel gestore delle eccezioni.
Una volta che ho finito di eseguire le istruzioni del gestore delle eccezioni riabilito le interrupt e
prendo il valore del registro EPC e lo rimetto nel PC per ripartire, al fetch successivo, dal punto
dove mi ero fermato.
Nella CPU c’è anche un registro di stato che memorizza se le interrupt sono attive.
Il gestore delle eccezioni
Analizziamo meglio come è fatto il gestore delle eccezioni.
La prima fase è quella di salvataggio dello stato della
computazione interrotta (salvo i registri,…)(saranno una
serie di store word). Lo stato lo salvo in un posto dove
nessuno lo modificherà.
Il gestore delle eccezioni ha a disposizione due registri
denominati $k0 e $k1 che sono registri del kernel che
può sempre utilizzare perché nessun programma vi
accede.
L’identificazione della periferica controlla il registro di
stato delle varie periferiche e quando trova una periferica
che è pronta fa il trasferimento andando nella sezione di
gestione della periferica specifica. Può succedere che ho
più periferiche pronte nell’intervallo di tempo che
intercorre nell’esecuzione delle prime fasi del gestore
delle eccezioni; quindi devo rendere interrompibile la
gestione della periferica nel caso che arrivi un nuovo
interrupt. Per evitare problemi assegno delle priorità alle
varie periferiche a seconda di quanto la periferica è
critica. La criticità di una periferica dipende da quanto
tempo il dato rimane memorizzato nel registro dati della
periferica prima di essere soprascritto nuovamente. Se
una periferica cambia stato ogni 100 nano secondi è
definita come periferica molto critica mentre se una
periferica cambia stato ogni 200 milli secondi è meno
critica. In base alla criticità della periferica interrompo la
gestione di una periferica per passare alla gestione di
un’altra periferica per poi tornare alla gestione della periferica precedente.
La fase di restore mi permette di recuperare tutti i dati che avevo salvato durante la fase di save, e in
fine ho la fase di return che mi fa tornare al programma in esecuzione.
Significati:
ITERRUZIONI
Anomalie nel flusso di controllo richieste dalle periferiche
ECCEZIONI
Anomalie che avvengono durante l’esecuzione delle istruzioni
48
Nella terminologia MIPS le eccezioni e le interruzioni vengono collettivamente
denominate eccezioni.
Nell’architettura MIPS il gestore delle eccezioni si trova a un indirizzo fisso che è 0x80000180.
Tutte le periferiche sono collegate al filo interrupt request del bus controllo. La procedura più
semplice del controllo se viene richiesto un interrupt consiste nell’OR di tutti i fili provenienti dalle
varie periferiche, sarà, poi, il gestore delle eccezioni a identificare quale periferica ha originato il
segnale controllando i bit di stato di ogni periferica.
Questa procedura richiede molte risorse e molti cicli di clock che peserebbero su una CPU con 10
MHz, ma non farebbero differenza su CPU molto veloci. Un altro difetto di questa procedura è che
il tempo aumenta in base al numero di periferiche che devo analizzare.
Una tecnica di accelerazione del riconoscimento della periferica è la vettorizzazione.
Per attuare questa tecnica aggiungiamo all’hardware k fili che denominiamo PID, Identificatore
della Periferica, che ci permetteranno di identificare quale periferica ha originato l’interrupt request.
Ogni periferica avrà un proprio codice preciso in un registro che non potrà essere modificato perché
è in grado di generare solo quei determinati segnali elettrici corrispondenti al codice di
identificazione della periferica (il registro in questione ha una struttura particolare nel senso che i
fili che andranno a formare i segnali in uscita dal registro saranno in parte collegati a massa e in
parte all’alimentazione).
Ricordo che il gestore specifico per una periferica ha un indirizzo ben preciso all’interno del gestore
delle eccezioni.
Nel gestore delle eccezioni verrà inizializzato
un vettore interruzione che contiene gli
indirizzi della gestione specifica delle varie
periferiche in base al codice di identificazione
della periferica.
Nel Program Counter dovrò inserire il
contenuto della “cella” del vettore che si trova
in posizione:
base_vettore_interruzioni + PID
(in questo caso il PID mi da lo spiazzamento
rispetto a un indirizzo base)
Un vantaggio di questa tecnica è che le fasi di
SAVE e RESTORE possono essere eseguite in
base alle esigenze che ho rispetto alla gestione
di quella periferica e non le devo per forza eseguire all’inizio e alla fine del gestore delle eccezioni.
L’architettura MIPS, però, non utilizza questo tipo di vettorizzazione ma ne utilizza
una variante: il registro di Causa ha un gruppo di bit che identifica la periferica.
Questa informazione viene usata dal gestore delle eccezioni per gestire nel modo
corretto l’interruzione.
Adesso che riesco a identificare in modo corretto una periferica devo anche capire che priorità ha e
se posso interrompere la gestione di un’altra interruzione per eseguire quella nuova.
In poche parole voglio realizzare qualcosa che faccia quello che è rappresentato da questo grafico:
49
Architettura
Sul livello di criticità 0 ho il programma che è in esecuzione, ad un certo punto mi arriva un
interrupt dalla periferica 3 (p3) e inizio a eseguire il gestore delle eccezioni. Dopo un po’ ho un
interrupt dalla periferica 2 (p2), ma ha un livello di criticità minore quindi la controllerò solo dopo
aver finito la gestione di p3. Ma, mi arriva un interrupt da p5 che ha il massimo grado di criticità
quindi passo subito alla sua gestione (lasciando perdere p3 e, ancora una volta, p2); al termine della
gestione di p5 torno a finire la gestione di p3 e poi passo alla gestione di p2, se nel frattempo non è
arrivato nessun altro interrupt da periferiche con criticità maggiore, e poi torno a eseguire il
programma che avevo interrotto.
La gestione delle priorità implica delle caratteristiche hardware (HW) e delle caratteristiche
software (SW).
Per quanto riguarda l’HW una periferica più è vicina alla CPU (come collegamento) più è
considerata ad alta priorità Æ DAISY CHAIN
Per rispettare questa logica il filo interrupt request entra ed esce da ogni periferica, la quale, può
decidere, a seconda del suo stato, se far passare il segnale così com’è oppure modificare il segnale
per farsi “servire” prima; per modificare il segnale ogni periferica avrà un circuito (con le porte
logiche adeguate) che mi fa interrompere le richieste delle periferiche con priorità più bassa della
periferica che sto considerando (ogni periferica farà la stessa identica cosa).
L’AND con il bit di stato della CPU maschera le interrupt, ma anche qui devo modificare qualche
cosa per far si che funzioni con la gestione delle priorità.
Aggiungo un registro alla CPU e lo denomino Registro Mascheramento Interruzioni (RMI). Questo
registro ha la funzione di mascherare le interruzioni provenienti da periferiche con un grado di
priorità più basso delle periferica che si sta gestendo in quel momento. È il sistema operativo che si
preoccupa che ci sia la corretta configurazione di bit nel RMI. Avremo tutti i bit, del registro RMI a
1 se sono al livello minimo di priorità, mentre tutti i bit saranno a 0 se sono al livello massimo di
priorità.
Lo schema qui sotto rappresenta la logica del mascheramento:
50
Gran parte delle architetture hanno anche un segnale di interruzione non mascherabile (NMI);
questo segnale è utile quando salta la corrente che quindi mi fa entrare nel gestore delle eccezioni e
mi permette da salvare il salvabile nei 2 o 3 millisecondi nei quali c’è ancora corrente nel circuito.
La sistemazione dei bit nel registro RMI avviene ad opera del gestore delle eccezioni.
Valutiamo, ora, la tecnica del gestore delle eccezioni rispetto al controllo di programma in base alla
banda passante e alla latenza.
Le aspettative di banda passante saranno inferiori rispetto al controllo di programma perché ho più
istruzioni da eseguire.
Rispetto alla latenza il controllo di programma è più reattivo e anche in questo caso attraverso il
gestore delle eccezioni ho una latenza maggiore.
Nonostante tutto (il costo delle complicazioni hardware,…) si utilizza la tecnica del gestore delle
eccezioni perché il Busy Wait è uno spreco di istruzioni dato dal fatto che la CPU continua ad
eseguire quelle determinate istruzioni, mentre col gestore delle eccezioni posso eseguire altri
programmi in contemporanea.
DMA (Direct Memory Access)
Con questa tecnica posso consentire un accesso diretto alla memoria a determinate periferiche che
implementano l’hardware necessario all’operazione.
Nell’accesso diretto alla memoria lo scopo è quello di liberare la CPU dal trasferimento dei dati.
Dobbiamo consentire alla periferica di accedere alla memoria e quindi la periferica deve poter
comunicare con il bus indirizzi inserendovi sopra un indirizzo e deve poter comunicare con il bus di
controllo per indicare che vuole scrivere in memoria.
In questo caso si dice che il bus ha più di un master perché anche la periferica può comunicare con
il bus di controllo.
Lo schema qui sotto riporta in rosso il ciclo normale di trasferimento dei dati dal registro dati della
periferica in memoria, mentre in blu viene riportato il trasferimento dati con DMA.
51
Architettura
La periferica ha bisogno di alcune informazioni per poter effettuare il trasferimento:
y Quanti (è un registro che contiene il numero di straferimenti da eseguire)
y Dove (è un registro che contiene l’indirizzo di memoria dove trasferirli)
y Deve poter scrivere sul bus indirizzi
y Deve poter scrivere sul bus controllo
Vediamo, ora, con un esempio pratico come ci si deve comportare:
Ho un programma che deve ricevere 115 caratteri da tastiera e deve memorizzarli.
Con il controllo di programma seguirei questo schema:
Inizializzazione
Quanti = 115
Dove = indirizzo di inizio
Periferica
pronta?
Quanti – –
Dove + 4
lw $x, k($z)
sw $y, dove
Quanti > 0
Per liberare la CPU di questo ciclo la periferica deve saper effettuare una specie di controllo di
programma.
Nel DMA eseguo questi passaggi:
1. Impostazione del DMAC (DMA Controller, sarebbero i registri della periferica)
Queste istruzioni di impostazioni vengono eseguite dalla CPU e sono scritte nel programma
che vuole fare il trasferimento.
la $13, KEYOBOARD
li $14, 155
sw $15, 16($13)
la $16, pippo
sw $16, 12($13)
#
#
#
#
metto in un registro l’indirizzo i ove sono
mappati i registri della periferica
carico quanti cicli di trasferimento devo
fare
# indirizzo di una variabile a caso
2. Start (DMAC)
Viene iniziato il DMA controller per eseguire le operazioni attraverso il cambiamento di
stato del registro di stato
3. Trasferimento
Nell’hardware della periferica avviene un ciclo analogo al controllo di programma
periferica pronta?
dove Æ sul bus indirizzi
52
dati Æ sul bus dati
write Æ sul bus controllo
Quanti – –
Dove + +
Quanti = = 0 ?
(se sì esco dal ciclo, altrimenti lo rieseguo)
(Per capire se ho finito i cicli di trasferimento nego le uscite del registro quanti e ne eseguo
un AND, il filo di uscita dall’and mi dirà se ho finito.)
Il programma che ha chiesto il trasferimento non ha modo di capire se il trasferimento è
iniziato, se ha finito, oppure se non è ancora iniziato.
4. Notifica (di fine trasferimento)
Quando diventa vera la condizione di fini trasferimento la periferica esegue una richiesta di
interrupt in modo da far capire che il trasferimento è stato completato
Dal punto di vista della banda passante il DMA è ottimo perché avviene al livello dell’hardware
della periferica, nonostante che possono verificarsi conflitti sul bus di controllo perché più
periferiche tentano di diventare il master del bus di controllo (cioè colui che in quel momento ha il
pieno controllo sul bus controllo).
Dal punto di vista della latenza il DMA è ottimo perché non bisogna aspettare molto tra il tempo in
cui il dato è pronto e il momento in cui è scritto in memoria (perché, anche in questo caso è la stessa
periferica che fa tutto).
Il DMA è molto costoso quindi una tastiera non avrà mai un accesso diretto alla memoria. Il DMA
viene usato principalmente per periferiche che generano grosse quantità di dati.
Modularizzazione del software
Cioè come si traduce da linguaggio ad alto livello in uno a basso livello.
La modularizzazione la eseguiremo a livello procedurale. Java è un ambiente di programmazione ad
oggetti mentre C e Pascal sono linguaggi di programmazione procedurali.
Una procedura è del codice che riceve in ingresso dei parametri, ha dei parametri in uscita e usa
delle risorse locali per fare delle istruzioni.
Normalmente una procedura viene richiamata da un’altra
procedura.
Per richiamare una procedura da un’altra procedura esegue le
seguenti operazioni (fasi svolte dalla procedura chiamante):
1. Predisposizione parametri di ingresso (la esegue la
procedura 1 che richiama la procedura 2)
Se il totale dei parametri è < 4 e sono da 32 bit si usano
4 registri appositi per questo scopo che sono: $a0, $a1,
$a2, $a3 (i registri da 4 a 7)
2. Trasferimento del controllo all’altra procedura.
Si utilizza l’istruzione jal (jump and link). Il “jump”
perché prevede un salto incondizionato, mentre “link”
serve per il ritorno alla procedura chiamante. Questa
istruzione memorizza l’indirizzo dell’istruzione che
viene dopo la jal nel registro $ra che è il registro return
address (è il 31° registro).
sintassi: jal <etichetta>
53
Architettura
i parametri di uscita vengono memorizzati nei registri $v.
(fasi svolte dalla procedura chiamata):
3. Acquisizione risorse
4. Esecuzione dell’attività specifica della procedura (ad esempio il calcolo del coseno)
5. Passaggio dei parametri in uscita verso la procedura chiamante. Per questa fase si utilizzano
i registri $v0 ($2) e $v1 ($3)
6. Trasferimento del controllo dalla procedura chiamata al chiamante.
Si utilizza l’istruzione jump register:
sintassi: jr $ra
Se abbiamo più procedure annidate ho dei problemi perché il registro $ra è in copia unica ed è
disponibile per ogni procedura. Quindi ogni procedura deve poter memorizzare un proprio registro
di ritorno alla procedura chiamante.
Per fare queste operazioni si ricorre all’utilizzo della memoria denominata stack.
Come già detto nel capitolo Convenzioni di uso della memoria lo stack fa parte della zona dei dati
dinamici; questa zona viene utilizzata durante l’esecuzione delle procedure.
Lo stack ha come inizio l’indirizzo 0x7FFFFFFF e si espande verso il basso, cioè verso indirizzi più
bassi.
I principali usi dello stack sono:
y Passaggio parametri che non possono essere passati utilizzando i registri $a
y Memorizzazione dell’indirizzo di ritorno alla procedura per ogni procedura
y Allocazione dello spazio per le variabili di ogni procedura
I gruppi di allocazione dello stack relativi ad ogni procedura vengono denominati stack frame (o
Record di attivazione della procedura).
Il caso più semplice è quello di una procedura che utilizza solo registri e non chiama altre
procedure.
Questa procedura, probabilmente, non avrà nessuno stack frame.
54
Questo tipo di procedure viene anche definito procedura foglia in riferimento a uno schema
ramificato come un albero dove le radici sono la procedura principale e i rami sono le procedure
figlie che richiamano a loro volta le procedure foglia.
Ciascuna procedura salva il proprio indirizzo di ritorno nel proprio stack frame, tranne la procedura
foglia che può eseguire il ritorno utilizzando direttamente la jump register.
Tutte le altre procedure devono caricare in memoria l’indirizzo di ritorno quando vengono chiamate
e poi devono leggere dalla memoria (e più precisamente dal loro stack frame) l’indirizzo di ritorno,
scriverlo dentro il registro $ra e fare la jump register.
Ogni procedura ha una propria dimensione dello stack frame che viene decisa dal programmatore
stesso.
Come si fa ad allocare lo spazio per lo stack frame?
Si utilizza un registro per tenere traccia di quanto spazio è stato usato dello stack. Questo registro,
nell’architettura MIPS, è il numero 29 che è denominato $sp (stack pointer); anche questo registro è
in copia unica e disponibile per tutte le procedure.
All’inizio della procedura principale questo registro viene impostato all’indirizzo di inizio dello
stack (0x7FFF FFFF). Dopo di che verrà allocato lo spazio per la procedura principale (ad esempio
256) quindi avremo nello stack pointer l’indirizzo 0x7FFF 8000.
Questo indirizzo punta all’ultima cella di memoria occupata.
La procedura figlia, che modificherà anch’essa lo stack pointer per aver il suo spazio di memoria,
prima di effettuare il ritorno al chiamante dovrà risistemare il contenuto del registro $sp come
l’aveva trovato in origine per far si che la procedura chiamante possa riferirsi a indirizzi di memoria
corretti per i suoi accessi (in memoria). Questo ripristino del registro $sp significa che ho liberato lo
spazio di memoria che era utilizzato da quella procedura.
L’allocamento dello stack frame, in poche parole, è una sottrazione dello spazio che necessita alla
procedura rispetto al contenuto corrente dello stack pointer.
Per liberare lo stack non faccio altro che eseguire una somma della stessa quantità che ho sottratto
in precedenza al contenuto corrente dello stack pointer.
Un errore nella fase di allocazione/disallocazione della memoria nello stack è disastroso, soprattutto
se fatto dall’ultima procedura che è stata chiamata perché si ripercuote su tutte le procedure che
sono state chiamate in precedenza.
Esempio di allocazione/disallocazione dello stack frame:
# inizio della procedura chiamata
subi $sp, $sp, 256
# alloco lo spazio per lo stack frame
sw $ra, 252($sp)
# salvo il registro $ra nello stack frame
# una eventuale procedura figlia mi deve restituire il valore di
# $sp come l’avevo in origine, altrimenti non riesco a recuperare
# l’indirizzo di ritorno corretto e/o di qualsiasi valore che abbia
# inserito in memoria nello stack frame.
Lw $ra, 252($sp)
# disallocazione dello stack frame, così facendo lo
addi $sp, $sp, 256
# stack pointer ha lo stesso valore che aveva prima
# di entrare nella procedura corrente
jr $ra
# ritorno alla procedura chiamante
Convenzione di uso dei registri durante le chiamate di procedura
Anche i registri $t e $s sono in copia unica e quindi vengono utilizzati da tutte le procedure
indistintamente, quindi qualsiasi procedura può modificarne il contenuto.
I registri $t (da $t0 a $t9) sono registri che contengono valori temporanei (t sta per temporary), cioè
qualsiasi procedura può modificarli senza preoccuparsi di doverli restituire alla procedura
55
Architettura
chiamante con lo stesso contenuto che avevano prima del trasferimento del controllo alla procedura
figlia.
I registri $s sono saved temporary e quindi qualsiasi procedura li deve restituire inalterati alla
procedura chiamante.
Se ci “immedesimassimo” nella procedura chiamata potremo modificare a nostro piacere i registri
$t e dovremo ricordarci di salvare in memoria il contenuto dei registri $s prima di modificarli e poi
ripristinarli prima di trasferire il controllo.
Se ci “immedesimassimo” nella procedura chiamante dovremo stare attenti perché i registri $t
potrebbero non avere più il valore iniziale quando effettuo una chiamata di procedura quindi se uso
i registri $t e vi inserisco del contenuto importante che mi servirà anche dopo la chiamata di
procedura devo ricordarmi di salvarne il contenuto nel mio stack frame altrimenti utilizzo i registri
$s perché la procedura chiamata ha l’obbligo di restituirmeli inalterati.
Passaggio di parametri
Quando passo un parametro ad una procedura questa è a tutti gli effetti una variabile della
procedura chiamante.
y Passaggio per indirizzo
Alla procedura figlia viene passato l’indirizzo di memoria a cui si riferisce una variabile e
quindi la procedura figlia controlla la variabile della procedura chiamante
y Passaggio per valore
viene effettuata una copia del valore contenuto nella variabile, quindi non viene modificato
il contenuto della variabile originale, ma viene modificata una copia di quella variabile che è
memorizzata nello stack frame della procedura.
Durante il passaggio per indirizzo nel registro $a0 (ad esempio) metteremo l’indirizzo di memoria
della variabile, mentre nel caso di un passaggio per valore, nel registro $a0, metteremo il valore
della variabile.
Esempi di codice assembly:
y Passaggio per indirizzo
la $a0, numero
y
# load address dell’indirizzo della variabile
Passaggio per valore
la $t1, numero
lw $a0, 0($t1)
#
#
#
#
prelevo l’indirizzo di memoria della
variabile
recupero con una load word il contenuto
della variabile che è salvato in memoria
Esercitazioni
datapath multiciclo, eccezioni/interruzioni in PCSPIM
Datapath multiciclo
Esercizio
Si chiede di aggiungere l’istruzione jal 2500 al set delle istruzioni del datapath multiciclo visto
a lezione. Si chiede di specificare le modifiche effettuate al datapath. Inoltre, si chiede di
specificare le modifiche effettuare nella FSM relativa.
Soluzione:
Per la modifica del pallogramma della macchina a stati finiti aggiungo un altro ramo in uscita
dal decode e lo chiamo, ad esempio, jal. Questo nuovo ramo avrà due stati. Nel primo sommerò
4 all’ingresso 0 di ALUsrcA dopo aver scritto il program counter proveniente dall’ingresso 3
del multiplexer. Nel secondo stato indicherò che voglio scrivere nel registro 31:
56
1° stato:
PCSource = 3° ingresso
PCWrite
ALUScrA = 0
ALUScrB = 4
ALUOp = add
2° stato
RegDst = 31
MemToReg = 0
RegWrite
Per quanto riguarda la modifica hardware del datapath dovrò aggiungere un ingresso sempre
riferito al registro 31 al multiplexer il cui segnale di controllo è RegDst. Si aggiunge un
ingresso al multiplexer dell’ingresso B della ALU con segnale fisso a 0.
Eccezioni/interruzioni in PCSPIM
y Le eccezioni = variazioni delle condizioni normali di funzionamento della CPU
y Conseguenze delle eccezioni Î cambiamento del normale flusso di esecuzione di un
programma
y La CPU “solleva” un eccezione e quindi cambia il flusso di esecuzione a seguito di:
o errore del programma (non voluto dal programmatore)
o richiesta del programma (voluta dal programmatore)
o evento esterno (indipendente dal programma in esecuzione)
y In tutti i casi, il flusso di esecuzione passa ad una locazione prefissata, dove si trova il
gestore delle eccezioni
Ci sono 3 categorie di eccezioni:
y Sincrone “involontarie” (causate da elaborazioni con valori non ammissibili con o da
indirizzi di memoria non accessibili)
y Sincrone “volontarie” (previste e richieste dal programmatore, ad esempio syscall e break)
y Asincrone (indipendenti dall’esecuzione del programma e dovute, ad esempio, a periferiche
di I/O)
Quando avviene una eccezione il processore effettua in automatico il salvataggio dell’indirizzo che
ha causato l’eccezione e il richiamo al gestore delle eccezioni collocato nello spazio kernel text a
partire dall’indirizzo 0x80000180. In PCSPIM il gestore delle eccezioni è il file Exception.s
Per determinare la causa dell’eccezione l’Exception.s osserva i registri del coprocessore 0 che sono
relativi alla gestione delle eccezioni. Per fare ciò vengono usate le istruzioni mtc0 (move to co –
processor 0) e mfc0 (move from co – processor 0).
I registri del coprocessore zero sono i seguenti:
y BadVAddr (registro 8) – contiene l’indirizzo di memoria alla quale il programma ha tentato
di accedere se avviene una eccezione causata da un accesso illegale alla memoria
y Status (registro 12) – contiene la maschera delle interruzioni e i bit di abilitazione
y Cause (registro 13) – contiene il tipo di eccezione e interrupt in attesa
y EPC (registro 14) – indirizzo dell’istruzione che ha causato l’eccezione
Struttura del registro CAUSE
57
Architettura
Tabella delle eccezioni:
Esempio di overflow aritmetico
.text
main:
# Genera un overflow aritmetico addizionando “con segno” due numeri
# positivi la cui somma NON è rappresentabile in complemento a 2
li $t0, 0x7fffffff
# massimo positivo in complemento a 2
li $t1, 2
# aggiungo abbastanza per superare il massimo
# positivo
add $a0, $t0, $t1
# cosa succede dopo aver eseguito questa
# istruzione?
Li $v0, 1
# stampa il risultato dell’operazione aritmetica
syscall
jr $ra
# fine
Il contenuto dei registri quanto si solleva l’eccezione:
PC = 80000180
EPC = 00400030
Cause = 00000030
BadVAddr= 00000000
Status = 3000ff12
HI = 00000000
LO = 00000000
Il messaggio scritto nel
di t x
Window:
[0x0040002c] 0x34090002 ori $9, $0, 2 ; 13: li $t1, 2 # aggiungo
abbastanza per superare il massimo positivo
58
[0x00400030] 0x01092020 add $4, $8, $9 ; 14: add $a0, $t0, $t1 # cosa
succede dopo aver eseguito questa istruzione ?
Exception occurred at PC=0x00400030
Arithmetic overflow
Le interruzioni (o interrupt)
y Sono tipicamente causate da dispositivi I/O
y Se il sistema ha abilitato le interruzioni avviene una interruzione del flusso normale di
esecuzione del programma per gestire l’eccezione
Struttura del registro STATUS
Interrupt Enabled indica che sono abilitate, in generale, le interruzioni.
Exception se è 1 indica che si è verificata una eccezione
User Mode se è 1 indica che sono in modalità utente altrimenti sono in modalità kernel
Interrupt mask contiene la maschera dei tipi di interruzione. Ogni bit fa riferimento ad una specifica
tipologia di interruzione, ad esempio il bit in posizione 8 se è 1 indica che ho un interrupt da
tastiera.
Quando si verifica una interruzione si settano i bit corrispondenti anche nel registro cause.
y
y
y
y
PCSPIM simula un terminale/console (una periferica di I/O) che permette di visualizzare
caratteri sul video e leggere caratteri dalla tastiera
Il terminale è composto da due dispositivi distinti e indipendenti:
- Transmitter: visualizza caratteri ASCII sulla Console
- Receiver: accetta caratteri ASCII dalla tastiera
Osservazione: essendo indipendenti, un tasto premuto sulla tastiera non viene
automaticamente mostrato sulla console; un programma deve esplicitamente fare l’eco di un
carattere letto dal Receiver inviandolo al Transmitter
In PCSPIM i dispositivi Receiver e Transmitter sono controllati tramite 4 registri i cui
contenuti appaiano a specifici indirizzi di memoria:
- Receiver Control 0xFFFF0000
- Receiver Data 0xFFFF0004
- Transmitter Control 0xFFFF0008
- Transmitter Data 0xFFFF000c
Il receiver control è un registro di cui utilizziamo solo i bit in posizione 0 e in posizione 1.
Il bit in posizione 0, denominato Ready, se è 1 mi indica che ho ricevuto un carattere dal Receiver,
mentre se è 0 non ho ricevuto nessun carattere; il bit di Ready passa da 0 a 1 quando un carattere è
arrivato dalla tastiera, ma non è stato ancora prelevato dal Receiver Data.
Il bit in posizione 1, denominato Interrupt Enable, se è 1 mi indica che ho gli interrupt del Receiver
abilitati altrimenti, se è 0, non ho gli interrupt abilitati.
Il receiver data contiene il codice ASCII del tasto premuto a partire dalla posizione 0 fino al bit in
posizione 7.
59
Architettura
Il transmitter control ha una struttura identica al receiver control. Il bit di ready se è 1 mi indica che
sono pronto ad inviare un carattere, se è 0 mi indica che sto scrivendo il carattere precedente. Per
quanto riguarda il bit Interrupt Enable ha lo stesso significato del receiver control.
Nel transmitter data i bit da 0 a 7 indicano il codice ASCII del carattere da stampare.
Per esempi di utilizzo dell’Exception.s si rimanda all’esercitazione 7 di architettura e al file zip
“esempi_spim”
Architettura 2 – Reti (8 / 1 / 2007)
Introduzione (8 / 1 / 2007)
Una rete è un insieme di protocolli e meccanismi fisici che permettono di trasportare dei bit
Le specifiche dei protocolli internet TCP/IP sono di dominio pubblico e si trovano in documenti
denominati RFC (Request For Comments)
Cosa è Internet: Descrizione del servizio
y Infrastruttura di comunicazione
permette applicazioni distribuite (web, e-mail, giochi,…)
y Servizi di comunicazione fornite alle applicazioni
o Connection less
o Connection – oriented (ad esempio quando facciamo una telefonata)
y Protocollo
Un protocollo è un insieme di regole che definisce il formato dei messaggi scambiati e che
consente a due entità di comunicare tra di loro e di comprendere la comunicazione.
Accesso alla rete
Servizi con e senza connessione
Quando un client e un server iniziano a comunicare si possono scambiare pacchetti di controllo
prima di spedire i dati reali.
Queste procedure dette di handshaking preparano le due componenti alla comunicazione. Tali
procedure sono alla base, ad esempio, del TCP.
Tuttavia possono anche esserci servizi che inviano direttamente i dati come nel caso dell’UDP.
La maggior parte delle applicazioni, tuttavia, ha bisogno di inviare i dati in maniera sicura e
affidabile per cui l’handshake serve proprio a questo compito. Si comprende come la connessione
con TCP, ad esempio, sia più sicura ma anche più lenta perché scambia non solo dati reali, ma
anche dati di servizio.
I servizi orientati alla connessione consentono:
y Trasferimento dati affidabile
y Controllo di flusso
y Controllo di congestione
I servizi senza connessione (esempio il protocollo UDP)
y Trasferimento dei dati non affidabile
y Niente controllo del flusso
y Niente controllo di congestione
y Questo tipo di servizio lo uso quando non ho bisogno della certezza che i dati siano arrivati
a destinazione (Streaming media, teleconferenza,…)
Dentro la rete
60
La rete Internet come la conosciamo è un insieme di router interconnessi
Il trasferimento dei dati avviene utilizzando due tecniche
y Circuit switching (commutazione di circuito) dove viene riservata della banda lungo la rete
per una connessione diretta tra i due utilizzatori. Questo avviene principalmente per le
comunicazioni telefoniche
y Packet switching (commutazione di pacchetto) dove non viene riservata la banda per la
comunicazione e i dati vengono inviati in rete a pacchetti
Circuit Switching
Quando una frazione fissa della capacità trasmissiva è stabilmente allocata a ciascun canale.
Ciascun utilizzatore ha a disposizione un canale trasmissivo dedicato, con la garanzia di poter
utilizzare tutta la sua capacità.
In poche parole
y Risorse dedicate, nessuna condivisione
y Prestazioni garantite
y È richiesto il setup della connessione
Ma in questo corso non ci occuperemo di questo tipo di trasmissione dati ma solo del Packet
Switching
Packet Switching (9 / 1 / 2007)
La commutazione di pacchetto è una tecnica di accesso multiplo a ripartizione nel tempo, utilizzata
per condividere un canale di comunicazione tra più stazioni in modo non deterministico, utilizzata
generalmente per realizzare reti di calcolatori. Si distingue dalla commutazione di circuito, che è
tipicamente usata nelle comunicazioni telefoniche.
Tali tecniche non comportano l’attivazione di una linea di comunicazione dedicata fra un
elaboratore ed un altro, ma consentono lo svolgimento simultaneo di più comunicazioni fra
computer, massimizzando così l’utilizzazione dei mezzi di trasmissione impiegati.
y
y
Ottimo per dati che viaggiano a gruppi
o Condivisione di risorse
o Niente setup di chiamata
Ci può essere una congestione eccessiva con ritardi e perdita di pacchetti
o Sono necessari protocolli per il trasferimento dei dati affidabili e un controllo di
congestione
I vari pacchetti si accodano in modo casuale all’interno del buffer del router in attesa di essere
trasmessi sul link (il collegamento fisico) quindi i pacchetti, non sempre, arrivano al destinatario
nell’ordine corretto per essere ricomposti e quindi sarà cura del destinatario dei pacchetti
identificarli e ricomporli nell’ordine corretto.
I “pacchetti” hanno lunghezza limitata o fissa, contrassegnati da un preambolo e un epilogo per
permettere il loro riconoscimento all’interno del flusso di dati, e che contengono le informazioni
necessarie per definire la destinazione del pacchetto.
Il packet switching si basa su un utilizzo statistico della rete: non tutti gli utenti invieranno enormi
quantità di pacchetti nello stesso momento quindi posso garantire un’ampiezza di banda costante, ad
esempio di 100 Kbps, pur avendo un link con una velocità modesta, ad esempio 1 Mbps.
61
Architettura
Continuando con l’esempio se voglio che 35 utenti abbiano una banda di 100 Kbps avrei necessità
di un link che abbia velocità 35 * 100 = 3,5 Mbps ma ciò non avviene nella realtà.
Quando la quantità di pacchetti supera l’ampiezza della banda e anche il buffer del router i pacchetti
vengono scartati perciò il mittente di questi pacchetti tenterà di rinviarli fino a quando non avrà
conferma che sono arrivati.
Il sistema di invio dei pacchetti è perciò definito store and forward cioè i pacchetti vengono
memorizzati nel buffer del router e poi inviati.
Per trasmettere un pacchetto con L bit su un link da R bit per secondo ho bisogno di L/R secondi.
L’intero pacchetto deve arrivare al router prima di essere trasmesso sul link successivo.
Alla fine avrò un ritardo (latenza) di 3*(L/R)
Esempio:
L = 7,5 Mbits
R = 1,5 Mbps
Ritardo = 15 secondi
Ciascuna tratta (da PC a router, da router a router e così via) ha un tempo di percorrenza di 5
secondi.
Per velocizzare il trasferimento i pacchetti hanno dimensioni piccole e nell’invio di un pacchetto
aspetto che sia arrivato al 1° router e non che sia arrivato al destinatario prima di inviare il
pacchetto successivo
Reti datagram e a circuito virtuale
Il problema principale diventa allora: Come faccio a instradare un pacchetto attraverso la rete:
Reti Datagram
y L’indirizzo di destinazione è contenuto nel pacchetto stesso
y Il percorso può cambiare durante la sessione
(ogni router ha delle informazioni particolari che consentono di instradare i pacchetti)
Reti a circuito virtuale
y Ogni pacchetto porta un tag (VirtualCircuitID). Il tag determina il percorso
y Il percorso è fissato al momento del setup del collegamento e rimane fissato per tutto il
percorso e per tutta la trasmissione
y I router mantengono lo stato per ogni collegamento
Ritardi e sorgenti di ritardo
Un pacchetto che attraversa una rete subisce un ritardo, legato in parte alle caratteristiche del
percorso ed in parte allo stato di carico della rete.
Il ritardo è dato da quattro sorgenti (o fattori) di ritardo:
62
1. ritardo di elaborazione (nodal processing)
dovuto al controllo degli errori e alla determinazione del link di output
2. ritardo di coda (queuing delay)
dovuto al fatto che i pacchetti in uscita non sempre vengono trasmessi immediatamente.
Infatti la linea in uscita può essere occupata da altri pacchetti in corso di trasmissione. In
questo caso, il pacchetto viene salvato in una memoria temporanea del commutatore detta
coda, per venir trasmesso appena possibile. Il tempo atteso dal pacchetto nella coda è
appunto detto ritardo di coda, e non è possibile stabilire a priori quanto ritardo di coda un
pacchetto subirà.
3. ritardo di trasmissione (transmission delay)
il tempo necessario per trasmettere il pacchetto alla velocità della linea di trasmissione. È
dato dal rapporto tra lunghezza del pacchetto e velocità della linea. Molti commutatori
utilizzano la tecnica store-and-forward, ovvero ricevono tutto il pacchetto, verificano i
checksum per controllare se ci sono stati errori di trasmissione, e poi lo accodano per la
ritrasmissione. Pertanto i ritardi di trasmissione dei commutatori attraversati devono essere
sommati tra loro.
4. ritardo di propagazione (propagation delay)
il tempo necessario al segnale fisico per propagarsi lungo una linea di trasmissione. Nei
mezzi di t x ivi come rame o fibra ottica, i segnali si propagano ad una frazione della
velocità della luce nello specifico mezzo trasmissivo, indicativamente 200.000 km/s. Quindi
il ritardo di trasmissione è stimabile in 5 μs/km.
È anche possibile che i pacchetti inviati tra due stessi host in momenti diversi subiscano ritardi
differenti. La variazione del ritardo subito dai pacchetti è detta di t
I Livelli
Ciascun protocollo regola normalmente solo una parte degli aspetti di una comunicazione. I diversi
protocolli sono organizzati con un sistema detto “a livelli” : a ciascun livello viene usato uno
specifico protocollo.
La divisione in livelli è fatta in modo che ciascun livello utilizzi i servizi offerti dal livello inferiore,
e fornisca servizi più “ricchi” al livello superiore. I diversi livelli in un host comunicano tra loro
tramite le interfacce. Ogni livello parla solo con quello immediatamente superiore e con quello
immediatamente inferiore. I protocolli regolano invece la comunicazione tra due entità dello stesso
livello, che serve a fornire servizi al livello superiore.
63
Architettura
I vari livelli sono organizzati in pile di protocolli. Le pile di protocolli sono un modo flessibile per
combinare componenti per realizzare un servizio.
Un esempio reale di una organizzazione a livelli protocollari, classico nelle trattazioni inerenti le
reti di calcolatori, è quello del percorso di una valigia in un viaggio aereo partendo dalla casa di
origine all’hotel di destinazione. Il primo livello che notiamo è quello della preparazione della
valigia: il turista prende i vestiti e ve li ripone per poi chiuderla, come ciò viene fatto è definito dal
protocollo del primo livello. Il secondo livello è quello dell’addetta alla valigie all’aeroporto di
partenza, il turista gli consegna la valigia (passaggio dal primo al secondo livello) e l’addetta attacca
alla valigia le informazioni relative al volo e alla destinazione. Qui notiamo l’aspetto fondamentale
dell’organizzazione a livelli protocollari, cioè che per l’addetta non è necessario conoscere come i
vestiti sono stati riposti nella valigia, altresì non è necessario per il turista conoscere le operazioni
che deve effettuare l’addetta, infatti il turista otterrà ciò che vuole (avere i vestiti all’hotel d’arrivo)
senza che ciò influisca affatto come gli altri protocolli debbano lavorare, a patto che lo facciano
correttamente.
La struttura serve ad adempiere ad alcuni compiti:
y controllo dell’errore;
y controllo del flusso;
y frammentazione e riassemblaggio;
y multiplexing, in modo che sessioni dello strato più alto possano condividere una singola
connessione dello strato più basso;
y instaurazione della connessione.
Tale architettura presenta vantaggi concettuali e strutturali anche se alcuni si sono opposti in
maniera decisa in quanto uno strato spesso duplica le funzionalità di un altro strato in maniera
ripetitiva.
Il livello più basso (1) è detto “livello fisico” e si occupa di gestire la trasmissione dei segnali
attraverso il mezzo di trasporto (cavo, fibra ottica, infrarossi, ecc...). Il livello più elevato è chiamato
“livello applicativo” ed è quello che permette all’utente di creare il messaggio da comunicare.
La divisione in livelli è piuttosto rigida a livello di specifica dei protocolli, mentre
nell’implementazione spesso diversi livelli vengono implementati insieme in uno stesso modulo
software.
Non è detto che due macchine che comunicano usino la stessa pila di protocolli. Ad esempio, se vi
connettete ad internet attraverso un modem voi appoggiate il livello di rete IP su una connessione
PPP, mentre il server a cui vi collegate probabilmente appoggia la rete IP su una connessione
ethernet.
In una rete a pacchetto ciascun livello della “pila protocollare” aggiunge ai pacchetti una
intestazione.
Esercitazione del 10 / 1 / 2007
1. Tra i vantaggi della rete a commutazione di circuito rispetto ad una rete a commutazione di
pacchetto c’è il seguente:
– garantisce una certa quantità di banda
2. Indicare quali tra gli strati della pila protocollare di Internet compiono il processo di
instradamento durante il percorso tra gli host mittente e destinatario
– rete
64
3. Se la velocità di propagazione del segnale in un mezzo è 250 milioni di m/s, l’ampiezza di
banda del link è di 25 kbps e la dimensione del pacchetto è 100 bit.
Calcolare la distanza a cui il ritardo di propagazione è uguale a quello di trasmissione (si
trascurino tutte le altre cause di ritardo)
– Ritardo di trasmissione =
L
R
L = 100 bit
R = 25 kps = 25 × 10 3
bit
s
d
v
d = distanza (la nostra incognita)
– Ritardo di propagazione =
m
s
Uguaglio le equazioni dei due ritardi ed esplicito la distanza
l
d L
= ⇒ d = v⋅
R
v R
100 bit
m
⋅
= 10 6 m = 1000 km
d = 2,50 × 10 8
bit
s
25 × 10 3
s
La tipologia è la stessa dell’esercizio precedente. I dati sono:
L = 100 bit
R = 2,5 Mbps
m
v = 2,50 × 108
s
d=?
Applico la formula calcolata nell’esercizio precedente:
l
m 1 × 10 2 bit
d = v ⋅ = 2,50 × 10 8
⋅
= 1 × 10 4 m = 10 km
bit
R
s
25 × 10 6
s
Un programma client è un programma che:
– inizia la conversazione (con un server), quindi chiede un servizio
Secondo il meccanismo di “Store & Forward” un messaggio di 7,5 Mbit deve passare per 4
router e 5 link ciascuno con ampiezza di banda di 1,5 Mbps per andare dall’host sorgente
all’host di destinazione.
Quanto tempo impiega il trasferimento in assenza di frammentazione del messaggio?
L
Il Ritardo di trasmissione
per ogni router. Ho 5 link quindi il ritardo complessivo sarà:
R
7,5 × 10 6 bit
L
5⋅ = 5⋅
= 25 s
R
6 bit
1,5 × 10
s
Se invece il trasferimento dell’esercizio precedente avvenisse con un messaggio
frammentato in 5000 pacchetti da 1500 bit l’uno.
Devo calcolare il tempo di trasmissione e lo indico con T.
L
l
T = + (Q − 1) ⋅
R
R
Dove Q è il numero di link, e l è la dimensione del pacchetto
v = velocità del segnale = 2,50 × 108
4.
5.
6.
7.
65
Architettura
7,5 × 10 6 bit
1,5 × 10 3 bit
+ 4⋅
T=
= 5,004 s
6 bit
6 bit
1,5 × 10
1,5 × 10
s
s
Ogni pacchetto ci mette 1ms per effettuare il passaggio sul link quindi a 5004 ms l’ultimo
pacchetto è arrivato a destinazione.
Normalmente i pacchetti su una rete Ethernet hanno dimensione di 1500 byte
8. In una rete con ampiezza di banda R = 100 Mbps e dove circolano pacchetti da 1550 byte, a
quale numero minimo di pacchetti per secondo il ritardo di coda è senz’altro dominante sui
ritardi di elaborazione, propagazione e trasmissione?
La
Per la risoluzione dell’esercizio bisogna tener conto del grafico della funzione
, cioè
R
dell’intensità di traffico. Più l’intensità di traffico tende a 1 più il ritardo di coda diventa
dominante. Si può dire che a partire dall’intensità di traffico = 0,8 il ritardo di coda diventa
dominante sulle altre cause di ritardo. Ricordo che nella formula a = tasso medio di arrivo
del pacchetto e viene misurata in pacchetti/secondo.
Per calcolare il numero minimo di pacchetti/secondo dovremo porre l’intensità di traffico =
1 e calcolare il valore di a.
L⋅a
I=
, dove L è la dimensione del pacchetto e R è la larghezza di banda del link.
R
Poniamo I = 1:
L⋅a
R
=1⇒ a =
R
L
Riepilogo delle unità di misura:
pacchetti
bit
a=
L=
sec
pacchetto
bit
s
R=
bit
sec
bit
pacchetti
s
=
= 8333
byte
bit
s
8 ⋅ 1,5 × 10 3
12 × 10 3
pacchetto
pacchetto
Il valore ottenuto è quello che si ha quando c’è la massima congestione
9. Se il ritardo di propagazione di un pacchetto di 1500 byte è di 60 microsecondi, quale deve
essere l’ampiezza di banda per avere un ritardo di trasmissione uguale?
d
= 60μs = 6 × 10 −5 s
v
L d
=
R v
8 ⋅ 1500 byte
L
R=
=
= 200 Mbps
6 × 10 −5 s
6 × 10 −5 s
10. Se la somma dei ritardi di trasmissione e di propagazione è 13μs per un pacchetto di 1500
byte su un tratto di 900 m, sapendo che il segnale si propaga a 300000 km/s calcolare
R
a= =
L
66
10 8
10 8
l’ampiezza di banda.
d L
+ = 13μs = T
v R
(
)
m
3 × 10 8
⋅ 8 ⋅ 1,5 × 10 3 bit
v⋅L
bit
s
R=
= 1,2 × 10 9
= 1,2 Gbps
=
(v ⋅ T ) − d ⎛ 3 × 108 m ⋅ 1,3 × 10 −5 s ⎞ − 9 × 10 2 m
s
⎟
⎜
s
⎠
⎝
11. È data una rete a commutazione di circuito con ampiezza di banda totale di 2 Mbps divisa in
40 circuiti uguali ma distinti.
Quanti utenti contemporanei possono usare questa rete, se in media hanno necessità di
trasmettere per il 10% della durata complessiva del collegamento durante il quale per
ciascuno di essi il segnale è campionato a 8 KHz (8000 campionamenti/secondo) con
campioni da 8 bit ogni 20 ms e subito trasmessi?
campionamenti
bit
= 64000
= 64 Kbps
8 bit ⋅ 8000
s
s
2 Mbps
= 50 Kbps per circuito
40
La risposta è nessun utente perché per una trasmissione ho bisogno di una banda di 64 Kps
ma ogni circuito me ne fornisce solo 50 Kbps.
Strato di applicazione (15 / 1 / 2006)
Come già detto si ha una pila di protocolli per il trasferimento. Ora analizzeremo il protocollo che
sta più a contatto con l’utente, cioè il protocollo dello strato di applicazione (http, ftp, smtp,…)
I vari protocolli contenuti nel livello applicativo si differenziano per quello che l’utente vuole fare. I
protocolli a questo livello nascondono all’utente tutto il sistema di trasporto dei dati.
Un processo è un programma in esecuzione su un host. Due processi possono comunicare fra loro
usando la comunicazione interprocesso (viene gestita dal Sistema Operativo).
Processi su host differenti comunicano utilizzando un protocollo dello strato applicativo.
Il protocollo dello strato applicativo definisce:
y I tipi di messaggio scambiati (richiesta, risposta,…)
y La sintassi dei messaggi cioè i campi contenuti nel messaggio e come sono delimitati
y La semantica dei campi cioè il significato delle informazioni contenute nei campi
y Regole per quando e come i processi inviano messaggi e/o rispondo ai messaggi
Attività di tipo “pull”: il client richiede qualcosa al server (questo è il meccanismo di
funzionamento del protocollo http)
Attività di tipo “push”: il server invia qualcosa al client. Questo tipo di attività non è nativa del web
quindi sarà il client ha fare una richiesta e poi il server invierà tutti i dati disponibili.
Indirizzamento dei processi
y Affinché un processo riceva dei messaggi deve avere un identificatore
y Ogni host ha un unico indirizzo IP a 32 bit
y Il solo indirizzo ip non è sufficiente a identificare un processo perché ci possono essere più
processi in esecuzione sullo stesso host
y L’identificatore include sia l’indirizzo IP che il numero di porta (è praticamente
l’identificatore del processo) associato al processo
67
Architettura
Ogni applicazione necessita di un tipo di trasporto
Perdita di dati (Data loss)
y alcune applicazioni (i.e. audio) possono tollerare qualche perdita
y altre applicazioni (i.e. file transfer, telnet) richiedono trasferimento di dati affidabile al
100%
Timing
y alcune applicazioni (i.e., telefonia Internet, giochi interattivi) richiedono bassi ritardi per
essere “efficaci”
Ampiezza di banda (Bandwith)
y alcune applicazione (i.e., multimedia) richiedono un minimo di ampiezza di banda
disponibile per essere “efficaci”
y altre applicazioni (quelle “elastiche”) possono usare qualsivoglia ampiezza di banda
riescano ad ottenere
Protocollo http (15 / 1 / 2006)
Il protocollo http è senza stato cioè il server non mantiene le informazioni sulle richieste passate dal
client.
La connessione al server web avviene tramite il protocollo TCP tramite questi passaggi:
y Client inizia connessione TCP – creazione del socket con la porta 80 del web server
y Il server accetta la connessione
68
y Scambio dei messaggi http (get,…)
y Chiusura della connessione TCP
Questi passaggi avvengono a ogni richiesta di pagina web
Se devo memorizzare la sessione e quindi mantenere lo stato ho bisogno di una applicazione in
grado di farlo perché non è parte del protocollo http.
Ora viene utilizzato il protocollo http 1.1 che una volta aperta la connessione TCP la lascia aperta
fino a quando non è il client a comunicare che ha finito di effettuare tutto il download della pagina e
degli oggetti referenziati (immagini, video, audio,…)
Il client elabora la pagina appena viene inviata dal server e invia le richieste di download degli
oggetti appena ne incontra la dichiarazione.
Connessione http non persistente
Viene creata una nuova connessione http con il server per ogni oggetto contenuto nella pagina web
69
Architettura
Connessione http persistente
All’inizio del trasferimento viene creata una connessione http; successivamente tutti gli oggetti
collegati alla pagina web vengono scaricati senza dover instaurare una nuova connessione.
Connessione http persistente senza pipelining
Il client presenta nuova richiesta solo quando risposta precedente è stata ricevuta
Connessione http persistente con pipelining
È di default in http/1.1
Il client invia richieste appena incontra un oggetto referenziato
http: messaggio di richiesta
GET /somedire/page.html HTTP/1.1
Host www.someschool.edu
User-agent: Mozilla/4.0
Connection: close (indica: dopo l’invio chiudi la connessione)
Accept-language: fr
http: messaggio di risposta
http/1.1 200 OK
Connection close
Alcuni codici di stato di risposta:
200 OK
301 Moved Permanently
400 Bad Request
404 Not Found
505 Http version not supported
Caricare form di input
Spesso una pagina contiene form di input. Per far si che il server li recuperi si utilizzano i metodi
Url/Get e Post.
Il metodo URL consiste nell’accodare l’input dei form all’indirizzo URL della pagina, invece, il
metodo POST fa si che l’input venga caricato nell’entity body del messaggio di richiesta http.
In generale un messaggio di richiesta http è formato dalle seguenti parti:
Dove cr e lf indicano carriage return e line feed cioè il carattere di “a capo”.
70
RTT Round Trip Time
tempo di viaggio di un piccolo pacchetto dal client al server e ritorno, o per meglio dire il tempo
necessario affinché in client invii una richiesta e attenda la risposta.
Formule di calcolo del RTT:
Connessione non persistente
Formula generale
t = 2 RTT + TT + Nfile ⋅ (2 RTT + TTI )
Formula per tempo totale con file html base e 10
t = 2 RTT + TT + 10(2 RTT + TTI )
oggetti
Connessione persistente senza pipelining
Formula generale
t = 2 RTT + TT + Nfile ⋅ (RTT + TTI )
t = 2 RTT + TT + 10(RTT + TTI )
oggetti
Connessione persistente con pipelining
Formula generale
t = 2 RTT + TT + RTT + ( Nfile ⋅ TTI )
t = 2 RTT + TT + RTT + (10 ⋅ TTI )
oggetti
dove con TT indico il tempo di trasmissione del file html base e con Nfile indico il numero di oggetti
collegati e con TTI indico il tempo di trasmissione di ogni oggetto collegato (immagine, audio,…).
Come mantenere lo “stato”?
Il protocollo http non permette di mantenere lo stato quindi vengono utilizzati dei Cookie che sono
semplici file di testo che possono contenere delle informazioni.
Questi file vengono salvati sul pc client e se presenti viene inviata la cookie header line assieme alla
richiesta http. Sul server è presente un database di back-end che tiene traccia dei cookie.
Protocollo ftp (16 / 1 / 2006)
y
y
y
y
Trasferimento di file a/da host
Modello client/server
ftp server porta 21
è un protocollo con stato
y
il client FTP contatta il server sulla porta 21 (connessione TCP)
y
y
y
y
il client ottiene l’autorizzazione
il client naviga nella directory remota inviando dei comandi
quando c’è un trasferimento file viene aperta una connessione sulla porta 20
è presente una connessione di controllo (“out of band” – fuori banda)
Esempi di comandi e risposte:
Comandi
y USER “username”
y PASS “password”
y LIST
ritorna la lista dei file nella directory
corrente
y RETR “filename”
effettua il download di un file
y STOR “filename”
effettua l’upload di un file
Risposte
y 331 username ok, password required
y 125 data connection already opened,
transfer starting
y 425 can’t open data connection
y 452 error writing file
71
Architettura
Posta elettronica (16 / 1 / 2006)
Il sistema di posta elettronica ha 3 componenti principali:
y User Agent:
programma che permette la composizione, ricezione, lettura e modifica dei messaggi di
posta elettronica (Eudora, Outlook Express,…)
y Mail Server:
permette l’immagazzinamento dei messaggi di posta e il loro invio.
Su ogni mail server ci sono diverse mailbox che sono associate ad un utente.
Il mail server ha, inoltre, una message queue per i messaggi di posta in uscita
y Protocollo di comunicazione: SMTP (Simple Mail Transfer Protocol)
Protocollo SMTP
y Usa TCP per trasferimento affidabile dei messaggi email da client a server sulla porta 25
y Trasferimento diretto: da server a server
y Necessita 3 fasi per il trasferimento dei messaggi:
o Handshaking (setup della connessione TCP)
o Trasferimento dei messaggi
o Chiusura connessione
y Interazione attraverso comandi e codici di risposta
Formato dei messaggi di posta
Nell’header sono principalmente indicati il mittente, il destinatario e l’oggetto del messaggio.
Il body contiene solo il testo del messaggio in formato ASCII a 7 bit.
È possibile anche aggiungere le estensioni multimediali o supportare il formato html attraverso i
MIME (Multimedia Mail Extension)
72
Tipi MIME
y Testo (html,…)
y Immagini (jpeg, gif,…)
y Audio (basic [8bit], 32kadpcm [32 kbps coding])
y Video (quicktime, windows media,…)
Protocolli di accesso alla posta
Servono per recuperare i messaggi dal mail server. Il protocollo SMTP è utilizzato solo per l’invio
dei messaggi di posta.
y POP (Post Office Protocol)
y IMAP (Internet Mail Access Protocol)
y HTTP (Hotmail, Yahoo! Mail,…)
Esempio di comunicazione con POP
Il protocollo POP3 ha diversi modi di download e mantenimento messaggi, ma non mantiene lo
stato delle sessioni:
y “download and di t ”: una volta scaricati sul client i messaggi vengono eliminati dal
server
y “download and keep”: viene mantenuta una copia del messaggio sul server
73
Architettura
Il protocollo IMAP
y Mantiene tutti i messaggi sul server
y Permette all’utente di organizzare i messaggi in cartelle
y Mantiene lo stato utente tra diverse sessioni
DNS (domain name system) (16 / 1 / 2006)
Serve per convertire un indirizzo web testuale in un indirizzo IP.
È implementato come protocollo dello strato di applicazione.
Il DNS è un database distribuito su vari server e con una determinata struttura per evitare che
quando avvengano errori il servizio non sia più disponibile, per evitare colli di bottiglia dovuti ad
un elevato traffico e per problemi di manutenzione.
Nessun server ha la mappatura completa che trasforma un nome in un indirizzo IP.
Ogni local ISP possiede un local name server che permette di risolvere determinati indirizzi
Ogni local name server è collegato tramite internet a dei root name server che contengono molte più
informazioni per la risoluzione nome/indirizzo IP.
I root name server vengono contattati dai local name server se non sono in grado di risolvere
nome/indirizzo IP. A loro volta i root name server possono contattare gli authoritative name server
se non riescono ad associare un dominio a un indirizzo IP.
Ci sono 13 root name server nel mondo
Esitono due tipi di richieste di risoluzione nome/indirizzo IP
La query ricorsiva pone il peso della risoluzione sul name server contattato e sarà il name server a
contattare gli altri name server se non è in grado di associare un indirizzo IP a dominio dato.
Nelle query iterate il name server contattao invia come risposta l’indirizzo di un altro name server
da contattare se non è in grado di effettuare la risoluzione.
Ogni volta che un name server ha imparato la mappatura la salva in cache. Dopo un certo timeout la
cache viene svuotata.
Tipi di record DNS
Il DNS è un database distribuito dei Resurce Record (RR)
RR format: (name, value, type, ttl)
74
y
y
y
y
Tipo A:
- name è l’hostname
- value è l’indirizzo IP
Tipo NS:
- name indica il dominio (es.: foo.com)
- value è l’indirizzo IP dell’authoritative name server per il dominio
Tipo CNAME:
- name indica l’alias per il canonical name (esempio: www.google.com è in realtà
www.google.akadns.net)
- value è il canonical name
Tipo MX:
- value è il nome del mail server associato con name
Web cache 2 (22 / 1 / 2007)
In alcune aziende si utilizza il web caching abbinato al proxy per tener traccia della navigazione
degli utenti e/o per impedire l’accesso a siti non autorizzati.
Per verificare che le pagine siano le più aggiornate il protocollo http è dotato di un sistema di
richiesta condizionata: if-modified-since che permette di ottenere la pagina solo se è stata
modificata dopo la data indicata.
Perché il Web Caching?
y Riduce il tempo di risposta per le richieste
y Riduce il traffico sul link esterno
y Una rete (Internet) densa di cache permette a provider “poveri” di distribuire i contenuti in
modo efficace
P2P (22 / 1 / 2007)
Peer to Peer (da pari a pari)
Il peer fa sia da client che da web server temporaneo
Directory centralizzata (design di “Napster”)
1. quando un peer si connette informa il server centrale fornendo indirizzo IP e contenuto della
ricerca
2. il server risponde con l’indirizzo del pc dove risiede il file
3. il client contatta direttamente il pc dove risiede il file per effettuare il download
Directory decentralizzate
y ogni peer è un leader di gruppo
y il leader di gruppo traccia i contenuti su tutti i pc dipendenti
75
Architettura
Query flooding
y Gnutella
y Niente gerarchia
y Uso del nodo di boot-strap
y Messaggi di unione (join)
y Richiesta inviata ai vicini (inteso come distanza tra gli id dei pc client)
y I vicini inoltrano la richiesta a un loro pari se non hanno l’oggetto cercato (e così via…)
y Il peer che ha l’oggetto invia il messaggio indietro al pari richiedente
eMule (22 / 1 / 2007)
y
y
y
È uno dei client p2p più diffusi
Il progetto eMule è nato il 13 maggio 2002 da Hendrik Breitkreuz, conosciuto come Merkur
Può collegarsi alle reti eDonkey e Kademlia
eMule suddivide i file in pezzi (chunk) da circa 9,28 MB l’uno.
Nei p2p tradizionali viene inviato lo stesso chunk a tutti i client richiedenti mentre eMule invia a
ogni utente un chunk differente facendo in modo che poi possano dialogare tra loro scambiandosi i
chunk senza contattare il server.
Prima di controllare se un pezzo è raro si tenta di completare i chunk da 9 MB già iniziati per poterli
condividere.
76
Identificazione file e client
Viene usata una funzione hash denominata MD4 per calcolare un identificatore univoco, detto
checksum, per ogni file condiviso. L’identificatore dipende esclusivamente dal contenuto del file e
questo permette di identificare file identici ma con nomi differenti, come anche di distinguere file
diversi che presentano nomi uguali.
Ogni utente per essere identificato possiede un hash, come accade per identificare i file.
Download
y Dopo aver determinato i siti fonte per un file, il client contatta ognuno di questi siti per
richiedere il file
y Ogni client mantiene una “download queue” di altri client che stanno chiedendo il file per il
download: quando un client raggiunge la cima di tale coda i vari client si contattano per
iniziare il trasferimento
Per altre informazioni sul Peer – to – Peer rimando alla presentazione del prof Bisiani che fornisco
in allegato al quaderno virtuale.
Strato di trasporto (22 / 1 / 2007)
y
y
Fornisce la comunicazione logica tra processi su host differenti
Il protocollo di trasporto è in esecuzione su sistemi terminali
o Lato mittente: spezza i messaggi in segmenti e li passa allo strato di rete
o Lato ricevente: riassembla i segmenti in messaggi e li pass allo strato di applicazione
y Ci sono più protocolli di trasporto disponibili: TCP e UDP
I vari protocolli a disposizione sono differenti e hanno differenti utilizzi:
y Con il protocollo TCP ho una consegna affidabile e ordinata con controllo di congestione e
di flusso, ma richiede un setup della connessione
y Con il protocollo UDP ho una consegna inaffidabile (non posso sapere se i pacchetti sono
arrivati a destinazione) e disordinata (i pacchetti arrivano in ordine casuale)
Multiplexing/demultiplexing
Sul sender avviene il multiplexing cioè i messaggi vengono segmentati in pacchetti e ogni pacchetto
contiene delle informazioni di header insieme a tutte le informazioni aggiunte dai protocolli
sovrastanti. In sostanza il multiplexing è la raccolta di dati provenienti da applicazioni diverse a cui
vengono aggiunti degli header.
Sull’host che riceve i segmenti di messaggio avviene la loro ricomposizione in un unico messaggio
per essere interpretato dai protocolli a livello di applicazione. In sostanza il demultiplexing consiste
nella consegna dei segmenti ricevuti all’applicazione a cui sono destinati.
Il multiplexing/demultiplexing è basato sui numeri di porta sorgente e destinazione e sugli indirizzi
IP.
Protocollo UDP
I segmenti UDP possono andare persi o essere consegnati in disordine (servizio best effort), ma al
protocollo non importa. È senza connessione cioè non avviene la fase di handshaking e ogni
segmento UDP è trattato in modo dipendente dagli altri.
Perché esiste UDP:
y Non si instaura una connessione (si evitano i ritardi relativi)
y Semplice: non serve informazione di stato
y Header dei segmenti piccolo
77
Architettura
y
Nessun controllo di congestione: UDP va alla massima velocità possibile (adatto
per applicazioni real time)
Il trasporto con protocollo UDP non è affidabile perciò l’affidabilità va conseguita a livello
applicativo; la gestione delle condizioni di errore dipende dall’applicazione.
Problema: Trovare gli errori nel segmento trasmesso
Il mittente:
y Tratta il contenuto del segmento come sequenza di interi a 16 bit
y Checksum:
somma del contenuto del segmento + complemento a 1
y Il mittente mette il valore del checksum nell’apposito campo dell’header
Il ricevente:
y Calcola il checksum sui contenuti del segmento ricevuto
y Confronta il checksum appena calcolato con quello contenuto nell’header del messaggio; se
sono identici non si sono verificati errori altrimenti si è verificato un errore di trasporto (bit
invertiti,…)
Principi di trasporto affidabile (22 / 1 / 2007)
y
y
Un canale di comunicazione inaffidabile determina una maggior complessità del protocollo
di trasporto affidabile (reliable data transfer – rdt)
È di fondamentale importanza negli strati applicativi, di trasporto e di collegamento
Generalità del trasferimento affidabile:
78
Esistono varie versioni di canali di trasporto (rdt) e ciascuna identifica un particolare tipo di canale
con le determinate complicazioni di protocollo per rendere il trasporto affidabile.
Rdt 1.0
y Il canale è già affidabile (Nessun errore sui bit, nessuna perdita di pacchetti,…)
y Non ho bisogno di avere protocolli complessi. Il mittente invia i dati e il ricevente legge i
dati dal canale di trasmissione.
Rdt 2.0
y Il canale non è affidabile e può “invertire” dei bit
y Come reagire agli errori?
o Acknowledgement (ACK): il receiver invia un messaggio al sender per dire che il
pacchetto è integro
o Negati Acknowledgement (NAK): il ricevente comunica esplicitamente che il
pacchetto contiene errori. In questo caso il mittente ritrasmetterà il pacchetto.
Esempi di rtd 2.0 in azione: (il primo caso è senza errori di trasporto mentre il secondo evidenzia gli
errori di trasporto)
79
Architettura
Rtd 2.0 ha un difetto (flaw):
Se si verificano errori sui pacchetti ACK e NAK il sender non sa cosa fare.
La ritrasmissione di questi pacchetti può dare origine a dei pacchetti duplicati ma che magari sono
stati ricevuti correttamente per questo è necessario implementare una gestione dei duplicati basati
su un numero di sequenza aggiunto a ogni pacchetto; con questo sistema eventuali pacchetti
duplicati vengono distrutti.
80
Il meccanismo usato per la trasmissione dei pacchetti è: stop & wait perché il mittente dopo aver
inviato un pacchetto attende la risposta e poi invia il pacchetto successivo.
Esistono anche protocolli rtd2 che inviano solo pacchetti ACK se il pacchetto è stato ricevuto
correttamente altrimenti non fa nessuna operazione
Rdt 3.0 canale con errori e perdite dati:
y Il canale può perdere qualsiasi tipo di pacchetto, quindi ACK, NAK e ritrasmissioni non
bastano per correggere l’errore.
y È necessario un timer.
y Il mittente attende per un lasso si tempo “ragionevole” l’arrivo del pacchetto ACK
y Se l’ACK non è arrivato nel lasso di tempo prefissato viene ritrasmesso il pacchetto
y Se l’ACK è semplicemente in ritardo e non è stato perso allora il receiver si troverà a gestire
un duplicato e lo fa come nel rdt 2.0 perché ogni pacchetto ha un numero di sequenza
y Il ricevente quando invia l’ACK deve specificare anche il numero di sequenza del pacchetto
che è arrivato correttamente
81
Architettura
Il sistema rdt 3.0 funziona ma le prestazioni di utilizzo del link fisico non sono ottimali.
Esempio:
link da 1 Gbps con un ritardo di propagazione end – end di 15 ms e pacchetti da 1KB
bit
8000
L
pkt
= 8μs
Ttrasm = =
R
9 bit
1 × 10
s
Ttrasm
0,000008s
=
= 0,000267
U=
RTT + Ttrasm 30,008 × 10 −2 s
U indica il fattore di utilizzo del link
Un pacchetto da 1KB ogni 30 ms indica un throughput di 33KB/s (= 264 Kbps) su un link da
1Gbps.
Throughput:
Il throughput non è da confondersi con la capacità del link: sia la capacità che il
throughput si esprimono in bit/s, ma mentre la prima esprime la velocità massima alla
quale i dati possono viaggiare, il throughput è un indice dell’effettivo utilizzo della
capacità del link. Il throughput è la quantità di dati trasmessi in una unità di tempo, il
secondo.
Protocolli con pipeline:
il mittente invia più pacchetti, senza attendere l’acknowledgement dei pacchetti precedenti. È da
tener presente che l’intervallo dei numeri di sequenza dei pacchetti va aumentato (Æ buffering dei
pacchetti al mittente e/o ricevente)
82
I protocolli con pipelining aumentano l’utilizzazione:
L
3⋅
R
U=
L
RTT +
R
Ci sono due protocolli detti a finestra scorrevole (sliding window): Go-Back-N e Selective Repeat
Go-Back-N:
Sul mittente:
y Numero di sequenza a k-bit nell’header del pacchetto
y “Finestra” (window) di (max.) N pacchetti consecutivi non confermati
y ACK(n): conferma tutti i pacchetti, fino a (e incluso) quello con numero di sequenza n –
“ACK cumulativo”
y Timer unico per il blocco di pacchetti non confermati (“in-flight”)
y timeout(n): ritrasmetti il pacchetto n e tutti quelli con numero di sequenza più alto nella
finestra
Sul ricevente:
y Solo ACK: si invia sempre l’ACK per il pacchetto con numero di sequenza più alto (mod N)
tra quelli correttamente ricevuti
y Si possono avere ACK duplicati (È sufficiente memorizzare expectedseqnum al lato
ricevente)
y Pacchetti non in ordine (out-of-order) [ACK per il pacchetto con numero di sequenza più
alto tra quelli ricevuti in ordine]
Go-Back-N in azione:
83
Architettura
1. Quale applicazione si basa sul meccanismo di trasmissione “out of band” (cioè apre una
porta per I comandi di controllo e apre un’altra porta per il trasferimento dati)?
- FTP
2. un client di posta elettronica che si basa su SMTP e POP3:
- non è sensibile alla quantità disponibile di larghezza di banda
3. Avete inviato una mail di risposta. Quali protocolli dello strato di applicazione sono usati
per la sola mail di risposta dal vostro host? (la casella di posta la consulto via web)
- HTTP perché il DNS l’ho già usato per accedere all’interfaccia web della casella di posta
4. Sul web server www.cr0.net è presente il file avente url:
http:www.cr0.net:8040/code/…/index.html
Qual è la porta usata dal server web in questione?
- 8040
5. Bob usa il server di posta elettronica disco.unimib.it dove riceve posta come
[email protected]. Ha istruito il server di posta di unimib.it all’indirizzo IP 149.132.2.20
dove riceve i mail come [email protected] a inoltrare tutti i mail ricevuti al server di posta di
disco.unimib.it all’indirizzo IP 149.132.157.35.
Una mattina aprendo il client di posta elettronica trova uno strano messaggio con la seguente
intestazione:
From: [email protected]
To: [email protected]
Subject: “Returned due to virus; was:” hello
Questo mail è stato inviato in automatico dal server di posta di Alice perchè il mail inviato
da Bob conteneva un virus.
Bob indaga ulteriormente perchè non conosce alcuna [email protected] e non si ricorda di
avere mai inviato tale mail.
84
L’intestazione del messaggio ritornato contengono le seguenti linee:
Received: from alpha.si.unimib.it ([149.132.2.3]) by srv1.disco.unimib.it
([149.132.157.35]) with Microsoft SMTPSVC(5.0.2195.5329); Wed, 4 Feb
2004 09:07:35 +0100
Received: from di t x.varian.com (mailwall1.si.unimib.it [149.132.2.21])
by alpha.si.unimib.it (Post.Office MTA v3.5.3 release 223 ID# 50664140U5000L500S0V35) with ESMTP di t for ; Wed, 4 Feb 2004 09:07:35
+0100
Received: from dozer.varian.com (dozer.varian.com [132.190.92.5]) by
di t x.varian.com (AIX5.2/8.11.6p2/8.11.0) with SMTP id i1487JP57972
for ; Wed, 4 Feb 2004 08:07:20 GMT
Received: from falcon.varian.com(132.190.92.15) by dozer.varian.com via
csmap id 8297; Wed, 04 Feb 2004 08:07:34 +0000 (GMT)
Received: from unimib.it ([213.215.166.226]) by falcon.varian.com
(AIX5.2/8.11.6p2/8.11.0) with SMTP id i1486gZ51484 for ; Wed, 4 Feb
2004 08:06:43 GMT
Analizzando queste linee Bob si accorge che c’è una incongruenza: qualcuno ha fatto finta
di essere Bob.
L’indirizzo da cui è partito il falso messaggio è:
- 213.215.166.226 perché questo indirizzo IP non corrisponde agli altri per il dominio
unimib.it perché si nota che iniziano sempre con 149.132…. come definito nella prima parte
della domanda
6. Bob usa il server di posta elettronica di disco.unimib.it [IP 149.132.157.35] dove riceve
posta come [email protected]. Ha istruito il server di posta di unimib.it [IP 149.132.2.20]
dove riceve i mail come [email protected] a inoltrare tutti i mail ricevuti al server di posta di
disco.unimib.it. Bob riceve una e-mail dalla sua amica Alice dal dipartimento di Fisica
dell’Università di Bari che contiene un’intestazione con le seguenti righe:
Received: from alpha.si.unimib.it ([149.132.2.3]) by srv1.disco.unimib.it
([149.132.157.35]) with Microsoft SMTPSVC(5.0.2195.5329); Thu, 24 Jun
2004
12:20:23 +0200
Received: from mailwall1.si.unimib.it ([149.132.2.21]) by
alpha.si.unimib.it
(Post.Office MTA v3.5.3 release 223 ID# 506-64140U5000L500S0V35) with
ESMTP
di t for ; Thu, 24 Jun 2004 12:20:00 +0200
Received: from mailwall1.si.unimib.it (localhost [127.0.0.1]) by localhost
(Postfix) with ESMTP id 2B5F47D45B for ; Thu, 24 Jun 2004 12:20:00
+0200
(CEST)
Received: from mail.uniba.it (mail.uniba.it [193.204.176.10]) by
mailwall1.si.unimib.it (Postfix) with ESMTP id 03CEE7D459 for ; Thu,
24 Jun
2004 12:20:00 +0200 (CEST)
Received: from mozart.uniba.it (mozart.uniba.it [193.204.184.2]) by
mail.uniba.it (X.XX.XX/) with ESMTP id i5OA310J013081 for ; Thu, 24
Jun 2004
12:11:50 +0200
Received: from pc_alice (pc_alice.fisica.uniba.it [193.204.188.224]) by
mozart.uniba.it (uniba.0/0.0.0) with SMTP id i5O9L8WP000780; Thu, 24
Jun
2004 11:21:09 +0200
Quale è la sequenza ordinata degli host attraverso cui viene rilanciata la e-mail inviata da
Alice?
85
Architettura
- pc_alice.fisica.uniba.it > mozart.uniba.it > mail.uniba.it > mailwall1.si.unimib.it >
alpha.si.unimib.it > srv1.disco.unimib.it
7. Per una connessione con www.google.it misurate che dal vostro host RTT vale 200 ms.
Volete scaricare un file htm base che referenzia 10 immagini. Il tempo di trasmissione di
ciascuna immagine è di 30 ms mentre il tempo di trasmissione per il file htm base è di 20
ms. Quanto tempo impiega il client per scaricare il tutto se usa una connessione http
persistente con parallelismo? Si assuma che il trasferimento avvenga su link non
congestionato e si trascurino altri possibili ritardi dovuti ai protocolli sottostanti della pila
protocollare di Internet.
TI = 30ms
TB = 20ms
con TI indico il tempo di trasferimento per ogni immagine e con TB indico il tempo di
trasferimento del file html base
1] connessione non persistente: t = 2 RTT + TB + 10 ⋅ (2 RTT + TI )
2] connessione persistente senza pipelining: t = 2 RTT + TB + 10(RTT + TI )
3] connessione persistente con pipelining: t = 2 RTT + TB + RTT + (10 ⋅ TI )
la risposta, applicando la formula, è: 0,92 s
8. In una rete locale ci sono in media 2 richieste al secondo verso server web esterni di oggetti
che in media hanno dimensione di 100kbyte. La ampiezza di banda della rete interna sia
100Mbps e quella del link di accesso ad Internet sia di 1Mbps. In media il ritardo Internet,
cioè il tempo che ci vuole da quando il router sul lato Internet (link da 1Mbps) invia la
richiesta a quando riceve la risposta, sia di 2s. Se disponiamo di un proxy server (web
cache), assumendo uno hit rate pari a 0,375 (cioè vi è il 37,5% di probabilità che l’oggetto
richiesto sia disponibile sul proxy), dire quale è il ritardo medio nel reperire un oggetto.
Calcoliamo quanto vale l’intensità di traffico sul link esterno:
aL
I=
R
pkt
a=2
s
KB
L = 100
pkt
R proxy = 100Mbps
(
)
(
)
pkt
bit
⋅ 8 ⋅ 1 × 10 5
pkt
s
= 0,0016
I=
9 bit
1 × 10
s
Rlink = 1Mbps
2
pkt
bit
⋅ 8 ⋅ 1 × 10 5
s
pkt
= 1,6
I=
6 bit
1 × 10
s
Il link esterno è quindi congestionato.
Verifichiamo se il link è ancora congestionato se inserisco l’utilizzo di un proxy:
2
86
(
)
pkt
bit
⋅ 8 ⋅ 1 × 10 5
s
pkt
I=
⋅ (1 − 0,375) = 1,6 ⋅ (1 − 0,375) = 1
9 bit
1 × 10
s
Nonostante l’utilizzo di un server proxy il link esterno rimane congestionato
9. In una rete locale ci sono in media 2 richieste al secondo verso server web esterni di oggetti
che in media hanno dimensione di 50kbyte. La ampiezza di banda della rete interna sia
100Mbps e quella del link di accesso ad Internet sia di 1Mbps. In media il ritardo Internet,
cioè il tempo che ci vuole da quando il router sul lato Internet (link da 1Mbps) invia la
richiesta a quando riceve la risposta, sia di 2s (TI). Se disponiamo di un proxy server (web
cache), assumendo uno hit rate pari a 0,375 (cioè vi è il 37,5% di probabilità che l’oggetto
richiesto sia disponibile sul proxy), calcolare il ritardo medio nel reperire un oggetto.
Innanzitutto controlliamo che il link esterno non sia congestionato come nell’esercizio
precedente:
aL
I=
R
pkt
a=2
s
KB
L = 50
pkt
R proxy = 100Mbps
2
Rlink = 1Mbps
(
)
(
)
pkt
bit
⋅ 8 ⋅ 5 × 10 3
s
pkt
I=
= 0,5
6 bit
1 × 10
s
Il link esterno non è congestionato quindi possiamo andare avanti nella risoluzione
dell’esercizio.
Calcoliamo il tempo necessario alla risoluzione delle richieste tenendo presente che
utilizzerò il link esterno (conseguentemente con i rispettivi ritardi) per il 62,5% delle volte e
utilizzerò solo la rete locale il 37,5% delle volte per recuperare i file sul server proxy.
T = (1 − 0,375) ⋅ (TI + TLA + TLAN ) + 0,375 ⋅ TLAN
Calcoliamo separatamente i ritardi (ritardo di internet [TI], ritardo del link di accesso [TLA] e
ritardo della LAN [TLAN]).
Il ritardo di internet è un dato del problema e vale 2 secondi.
bit
8 ⋅ 5 × 10 3
L
pkt
TLA = =
= 0,4 s
R
6 bit
1 × 10
s
bit
8 ⋅ 5 × 10 3
L
pkt
TLAN = =
= 0,004 s
bit
R
8
1 × 10
s
Ora calcolo il ritardo totale T:
2
(
)
87
Architettura
T = (1 − 0,375) ⋅ (TI + TLA + TLAN ) + 0,375 ⋅ TLAN = 0,625 ⋅ (2s + 0,4s + 0,004s ) + 0,375 ⋅ 0,004s =
= 1,504s
Principi di trasporto affidabile 2 (29 / 1 / 2007)
Continuiamo la trattazione sui protocolli a finestra scorrevole
Selective Repeat
y C’è un buffer sul receiver e quindi non scarto i pacchetti fuori ordine.
il buffer è di dimensione uguale a quello della finestra di trasmissione
y Il receiver invia un ACK individuale per ogni pacchetto
y Il sender invia nuovamente i pacchetti per cui non ha ricevuto l’ACK (il sistema è dotato del
solito timeout)
y Vengono utilizzati sempre dei numeri di sequenza
La finestra di trasmissione si sposta solo quando arriva l’ACK del pacchetto (o dei pacchetti) che
sono all’inizio altrimenti li attende. Se il timeout è elevato la trasmissione si può fermare in attesa
che arrivino gli ACK dei pacchetti.
88
Sorge, quindi, un problema nei numeri di sequenza perché, se la sequenza è corta, e il sender non
riceve gli ACK dei pacchetti inviati invierà nuovamente gli stessi pacchetti, ma il receiver li aveva
ricevuti correttamente quindi la sua finestra si è spostata e quindi i pacchetti che riceverà non
potranno essere rilevati come duplicati ma verranno considerati nuovi e inseriti in posizione
sbagliata e il file che risulterà sarà corrotto.
89
Architettura
TCP (Generalità)(29 / 1 / 2007)
y
y
y
y
y
y
y
Da punto a punto (un sender e un receiver)
Stream (flusso) di byte in ordine e affidabile
Buffer per invio e ricezione
Ha il pipeline
Full Duplex – scambio di dati bidirezionale sulla stessa connessione e MSS (Maximum
Segment Size – la massima quantità di dati che possono essere prelevati e posizionati in un
segmento)
Connection – oriented quindi necessita di handshaking
Controllo di flusso e controllo di congestione
Struttura dei segmenti TCP
90
Il TCP non è legato al pacchetto ma al byte. Il numero di sequenza è il primo byte presente nel
segmento. L’ACK come numero di sequenza riporterà il primo byte che il ricevitore si aspetta che
venga inviato. Ad esempio se ho inviato un messaggio da 32 byte che ha numero di sequenza 10
(vuol dire che ho inviato altri 10 byte prima di quel segmento) l’ACK che mi verrà mandato avrà
come numero di sequenza 42 che sarà il primo byte del segmento successivo.
Il codice checksum su 16 bit serve a ben poco per individuare errori, ma il vantaggio dei livelli di
protocolli su cui appoggia il TCP gli garantiscono di avere dati il più possibile senza errori perché i
protocolli sottostanti sono dotati di un sistema di controllo errori più robusto ed efficiente.
Se al receiver arriva un segmento fuori ordine questo verrà bufferizzato nella finestra di ricezione
nel posto in cui dovrebbe trovarsi, ma come numero di sequenza dell’ACK verrà inviato sempre
quello del primo byte del segmento successivo rispetto a quelli arrivati in ordine sequenziale
corretto.
Possibili casi di ritrasmissione
TCP Round Trip Time e Timeout
Come si calcola il RTT e il timeout per ogni singolo pacchetto inviato?
Il timeout deve essere almeno uguale al RTT, ma il RTT varia per ogni pacchetto perché non è detto
che ha ogni pacchetto occorra lo stesso tempo per essere inviato e attendere che sia arrivato l’ACK.
Se il timeout è troppo breve avrò ritrasmissioni di pacchetti superflue mentre se è troppo lungo avrò
una reazione lenta alla perdita dei segmenti (= pacchetti).
Per calcolare un timeout corretto devo riuscire a stimare il RTT. Per far ciò faccio uso del
SampleRTT cioè questo mi da il tempo che intercorre tra l’invio del pacchetto e la ricezione
91
Architettura
dell’ACK, poi eseguo delle medie ponderate tra l’insieme delle stime recenti di RTT e il
SampleRTT.
EstimatedRTT = (1 − α ) ⋅ EstimatedRTT + α ⋅ SampleRTT
Generalmente α = 0,125
L’EstimatedRTT mi da una stima di quanto potrebbe valere RTT in base anche alla stima effettuata
per i pacchetti precedenti.
Si passa, quindi, alla stima della varianza di SampleRTT:
DevRTT = (1 − β ) ⋅ DevRTT + β ⋅ SampleRTT − EstimatedRTT
Generalmente β = 0,25
Si passa quindi al calcolo del timeout che è l’EstimatedRTT più un margine di sicurezza dato da
DevRTT:
Timeout = EstimatedRTT + 4 ⋅ DevRTT
TCP: generazione di ACK
Ritrasmissione veloce: rinvia il segmento prima che scada il timeout
Se sender riceve 3 ACK duplicati per lo stesso dato, suppone che segmento dopo quello con ACK
sia perso e quindi effettua la ritrasmissione veloce.
TCP controllo di flusso
Il mittente non riempie i buffer del ricevente inviando troppi dati e troppo velocemente.
Nelle specifiche originali del TCP il buffer di ricezione non poteva essere più grande di 64KB.
Nell’implementazione Windows del TCP a livello di handshaking viene specificato un
moltiplicatore per le dimensioni del buffer di ricezione.
Il ricevente informa il mittente sullo spazio disponibile nel buffer tramite il campo RcvWindow nel
segmento TCP.
TCP: gestione della connessione
Apertura della connessione:
92
Passo 1: client invia segmento di controllo TCP SYN al server (specifica numero di sequenza
iniziale)
Passo 2: server riceve SYN, risponde con segmento di controllo SYNACK
y Conferma ricezione SYN
y alloca buffer
y Specifica numero di sequenza iniziale server Æ receiver
Passo 3: il client riceve SYNACK, invia segmento con campo SYN = 0 ed eventualmente dati
Il numero di sequenza iniziale è arbitrario
Chiusura della connessione:
1. host client invia segmento TCP con il controllo FIN all’altro host
2. host server riceve FIN e risponde con ACK
Ci sono due richieste di chiusura perché il protocollo TCP è a due vie.
C’è comunque un timeout dopo il quale l’host decide che la connessione è chiusa.
L’ACK che viene inviato al secondo passo della chiusura della connessione indica che ho ricevuto
il messaggio. La chiusura della connessione può anche dipendere dall’attesa di un comando da parte
dell’utente. Quando l’applicazione è d’accordo sul chiudere la connessione invia un segmento con
FIN. L’ACK di risposta può andare in timeout e la connessione è chiusa.
Controllo di congestione
Scenario 1:
Scenario 2
93
Architettura
y
y
y
94
più c’è congestione più pacchetti vengono ritrasmessi e di conseguenza aumenta la
congestione e diminuisce la capacità della rete
il controllo di congestione è un controllo end to end senza assistenza della rete
il sender limita la trasmissione
CongWin (finestra di congestione) è dinamica ed è in funzione della congestione percepita sulla
rete.
Come fa il sender a rilevare la congestione?
Attraverso a eventi di timeout per un pacchetto o alla ricezione di 3 ACK duplicati
Ci sono diversi sistemi per ridurre la congestione:
y Decremento moltiplicativo:
taglia CongWin di metà dopo un evento di perdita pacchetti
y Incremento additivo:
incremento CongWin di 1MSS ogni RTT in assenza di eventi di perdita
95
Architettura
y
Slow Start
quando inizio la connessione CongWin = 1 MSS per poi aumentare esponenzialmente per
ogni ACK ricevuto fino al primo evento di perdita.
L’aumento esponenziale è dato dal fatto che all’inizio la trasmissione è lenta ma l’ampiezza
MSS
di banda può essere molto maggiore di
e quindi è desiderabile aumentare la velocità a
RTT
un tasso ragionevole
I trasferimenti di piccoli file in TCP non sono molto veloci perché all’inizio ho una bassa velocità
per effetto dello Slow Start.
Principio:
y 3 ACK duplicati indicano che la rete è in grado di consegnare qualche segmento pur essendo
congestionata
y Se vado in timeout prima di ricevere 3 ACK duplicati è più allarmante e in questo caso
CongWin viene riportata a 1 MSS per poi crescere nuovamente in maniera esponenziale
sino alla metà del valore che aveva (CongWin) prima del timeout.
Raffiniamo il principio dello Slow Start:
Quando CongWin raggiunge ½ del suo valore prima del timeout l’incremento passa da esponenziale
a lineare:
96
Fairness
Se N connessioni TCP condividono un collo di bottiglia, ciascuna dovrebbe ricevere 1/N della
capacità del link
97
Architettura
Il meccanismo di controllo della congestione è equo se la frequenza trasmissiva media di ciascuna
connessione è approssimativamente R/N, in altre parole, ciascuna connessione ottiene la stessa
proporzione di banda del collegamento
Throughput TCP
Il throughput è l'effettiva velocità di trasferimento dei dati da un computer ad un altro, considerando
compressione dei dati, correzione degli errori ed eventualmente il tempo richiesto per la
connessione.
Qual è il throughput medio di TCP in funzione della dimensione della finestra e di RTT?
W
Sia W la dimensione della finestra quando si verifica una perdita, il throughput è
. Subito
RTT
W
W
e quindi il throughput è
.
dopo la perdita la finestra si riduce a
2
2 ⋅ RTT
W
Il throughput medio è: 0,75 ⋅
RTT
Modellazione della latenza
Quanto tempo ci vuole è prima di ricevere un oggetto da un server Web dopo l’invio della richiesta?
Se ignoriamo la congestione, la latenza è influenzata da:
98
y
y
y
Handshaking del TCP (creazione della connessione TCP)
Ritardo di trasmissione (Data Transmission Delay)
Slow Start
Assumiamo le seguenti ipotesi:
y Il link tra client e server ha ampiezza di banda R
y S = MSS (bit)
y O = dimensione dell’oggetto in bit
y Non avvengono ritrasmissioni (non ci sono perdite o corruzioni dei dati)
1° ipotesi: finestra di congestione fissa
W ⋅S
S
ciò significa che l’ACK per il primo segmento in finestra ritorna prima che i
> RTT +
R
R
dati della finestra siano stati inviati.
O
latenza = 2 ⋅ RTT +
R
99
Architettura
2° ipotesi: finestra di congestione fissa 2
W ⋅S
S
cioè c’è l’attesa dell’ACK dopo l’invio dei dati nella finestra
< RTT +
R
R
O
WS ⎞
⎛S
latenza = 2 ⋅ RTT + + (K − 1) ⋅ ⎜ + RTT −
⎟
R
R ⎠
⎝R
1. Quali dei seguenti servizi sono forniti sia da TCP che da UDP
- Controllo di errore e inoltro dei dati all’applicazione appropriata
2. Date le seguenti parole a 8 bit
1111 1111
0110 0001
0000 0010
indicare la checksum UDP.
Per calcolare la checksum UDP bisogna sommare le 3 parole a 8 bit e farne il complemento
100
a 1. Se sommiamo il complemento a 1 e la somma ottenuta in precedenza otteniamo tutti i
bit 1 (questo indica che non ci sono stati errori).
1111 1111 + (1° parola)
0110 0001 = (2° parola)
10110 0000 +
0000 0001 = (sommo il riporto che ho messo sul bit 9)
0110 0001 +
0000 0010 = (sommo la 3° parola)
0110 0011
faccio il complemento a 1 e ottengo
1001 1100
3. Quale tra i seguenti numeri di porta è plausibile nella richiesta da un client ad un server
IMAP?
Il client sceglie a caso una porta tra 1024 e 65536 che sono le porte di libero utilizzo, mentre
le porte da 0 a 1023 sono quelle dei servizi ben noti a cui i server rispondono e i client non
possono usare
- la risposta è 13111
4. I meccanismi di Go-Back-N e Selective Repeat hanno in comune:
- La presenza di un buffer con finestra scorrevole sul lato sender
5. Qual è la massima dimensione L di un file (in byte) per la quale i numeri di sequenza TCP
non si ripetono mai?
- 4 GB
perché i numeri di sequenza possono arrivare fino a rappresentare 232 byte siccome il
numero di sequenza viene rappresentato su 32 bit
6. Supponiamo che ci sia un link con banda 900 kbps che supporta 10 applicazioni
client/server su TCP in contemporanea e che stiano trasferendo file di grandi dimensioni.
Secondo il meccanismo di fairness di TCP, ciascuna connessione in media ottiene 1/10 della
banda disponibile, cioè 90 kbps. Se si aggiunge una undicesima applicazione che usa 20
connessioni TCP parallele per trasferire file di grandi dimensioni quanto sarà la frazione di
banda in media occupata da questa nuova connessione?
Ci sono 10 + 20 = 30 connessioni contemporanee in cui ciascuna connessione ottiene 1/30
della banda disponibile.
Le 20 connessioni contemporanee occupano 2/3 della banda e quindi
- 600 kbps
7. Consideriamo il caso di 2 terminali collegati tra loro da un link con R = 1 Gbps e aventi
RTT = 30 ms.
Supponiamo che ogni pacchetto abbia L = 1000 byte.
Quanto deve essere grande la finestra di ricezione affinché l’utilizzazione del canale sia
continua?
Il numero di pacchetti minimo è:
L
n⋅
R =1
U=
L
RTT +
R
pongo U = 1 perché sto trasmettendo in modo continuo. Ho indicato con n il numero dei
101
Architettura
pacchetti che devo calcolare.
30ms
0,03s
RTT
=
= 1+
= 3751
n = 1+
(8 ⋅ 1000)bit
L
8μs
bit
r
1 × 10 9
s
8. Scaricate un file di grandi dimensioni via http alla velocità media C = 50 KBps da un sito
con RTT = 90ms.
La dimensione dei singoli pacchetti L = 500 KB.
Trascurando gli eventi di timeout si hanno solo ACK ripetuti 3 volte per cui si passa con
nL
incremento lineare dalla finestra con dimensione di
alla finestra con dimensione nL e
2
poi si ripete per l’arrivo di 3 ACK duplicati.
Il valore di n, numero di pacchetti massimo nella finestra, è quindi:
n⎞ n
1⎛
⎜n + ⎟⋅
2⎝
2⎠ 2 3
= n
n
4
2
in media sul periodo tra 0 e n/2 avevo 3/4n segmenti.
C = 50 KBps
RTT = 90 ms
L = 500 KB
3 nL
C= ⋅
4 RTT
B
90 × 10 −3 s ⋅ 50 × 10 3
4 RTT ⋅ C 4
s = 12
= ⋅
n= ⋅
2
3
3
L
5 × 10 Β
(con B indico i Byte).
- 12 sono i segmenti nella finestra di congestione
102
Strato di rete (19 / 2 / 2007)
Lo strato di rete (network layer) è presente in ogni host e in ogni router.
A livello dello strato di rete (protocollo IP) vengono spediti pacchetti da macchina a macchina.
La comunicazione a livello di applicazione risulta essere di tipo logico perché i processi applicativi
non si preoccupano dei dettagli della struttura fisica utilizzata per il trasporto dei dati.
Il TCP visto da software manda una sequenza di byte in continuità, mentre a livello IP si trasferisce
un pacchetto da una macchina all’altra senza tener conto delle connessioni fisiche e delle
caratteristiche dei pc.
A livello dello strato di rete i pacchetti vengono chiamati datagrammi.
I router implementano il protocollo di rete e i protocolli sottostanti ma non implementano nessun
protocollo degli strati superiori della pila protocollare.
È possibile identificare due funzioni principali del protocollo dello strato di rete:
• Forwarding (inoltro): quando un router riceve un pacchetto, lo trasferisce sull’appropriato
link di uscita
• Routing (instradamento): quando viene determinato, tramite algoritmi d’instradamento, il
percorso che i pacchetti devono seguire
Già con il protocollo TCP abbiamo visto che era necessario un handshake a tre vie per il setup della
connessione; analogamente, alcune architetture di rete (ATM, frame-relay,…) richiedono che i
router effettuino l’handshake per impostare lo stato prima che i pacchetti inizino a fluire.
I modelli dei servizi di rete definiscono le caratteristiche del trasporto punto-punto di dati tra
sistema terminale d’invio e di ricezione.
Il livello di rete potrebbe offrire vari servizi al protocollo di trasporto tra i quali:
• Consegna garantita: questo servizio assicura che il pacchetto giunga, prima o poi, alla
propria destinazione
• Consegna garantita con ritardo limitato: questo servizio non solo garantisce la consegna
del pacchetto, ma anche il rispetto di un limite di ritardo specificato
• Consegna in ordine: questo servizio garantisce che i pacchetti giungano a destinazione
nell’ordine in cui sono stati inviati
• Minima ampiezza di banda garantita: questo servizio a livello di rete emula il
comportamento di un collegamento trasmissivo dal bit – rate specificato tra host di invio e di
ricezione anche se l’effettivo percorso da capo a capo può attraversare diversi link fisici.
Finché l’host d’invio trasmette bit a una frequenza inferiore al bit – rate specificato non si
verifica perdita di dati che giungono a destinazione con un ritardo predeterminato.
• Jitter limitato: questo servizio garantisce che il lasso di tempo tra la trasmissione di due
pacchetti consecutivi sia uguale a quello di ricezione (o che non superi il limite di tolleranza
specificato)
Internet, però, mette a disposizione un solo servizio, noto come best – effort, ossia “col massimo
impegno possibile”. Il servizio best – effort, però, non garantisce di preservare la temporizzazione
tra pacchetti, né la loro ricezione nel medesimo ordine d’invio e nemmeno che vengano consegnati.
Esistono, tuttavia, reti che offrono servizi aggiuntivi al servizio minimalista offerto da best – effort,
ad esempio l’architettura ATM che offre due modelli di servizio: bit rate costante (CBR Constant
Bit Rate) e il servizio a bit rate disponibile (ABR, Avaiable bit rate).
103
Architettura
Reti a circuito virtuale (VC)
Internet è una rete a datagrammi che ha molte architetture alternative tra cui ATM, frame – relay e
X.25 che utilizzano connessioni a livello di rete dette circuiti virtuali.
Un circuito virtuale consiste in un percorso prefissato a livello di setup della connessione su cui
passeranno i pacchetti tra l’host sorgente e l’host destinazione, ogni collegamento di questo tipo ha
pacchetti che sono identificati dal numero del circuito virtuale che determinerà il percorso che il
pacchetto deve seguire.
Per stabilire una connessione virtuale bisogna esaminare la rete per precostruire le tabelle di routing
per l’instradamento del pacchetto.
Nelle reti a circuito virtuale i router devono mantenere le informazioni sullo stato delle connessioni
attive.
La rete di tipo ATM è ancora usata a livello di collegamento telefonico.
Router (19 / 2 / 2007)
Un router ha diverse componenti:
y Porte di ingresso (input port). Completano il collegamento elettrico (riquadri contrassegnati
da F) e volgono funzioni a livello di link (riquadri L). Svolgono anche operazioni di ricerca
(riquadri R) per impostare il corretto inoltro. Spesso più porte di ingresso sono riunite in una
sola scheda detta line card.
y Struttura di commutazione (switching fabric). La struttura di commutazione che connette
fisicamente le porte di ingresso a quelle di uscita
y Porte di uscita (output port). Memorizzano i pacchetti che provengono dalla struttura di
commutazione e li trasmettono sul collegamento in uscita. Una porta di uscita presenta,
quindi, funzionalità inverse rispetto ad una porta d’ingresso. Nei collegamenti bidirezionali
la porta di uscita verso un collegamento è solitamente accoppiata alla porta d’ingresso di
quel collegamento sulla stessa scheda di linea
y Processore di instradamento (routing processor). Esegue i protocolli di instradamento,
conserva le informazioni d’instradamento e le tabelle di inoltro ed effettua funzioni di
gestione della rete all’interno del router.
104
Un router ha due funzionalità chiave:
• Algoritmi di routing (RIP, BGT,…) che decidono su quale link spedire il pacchetto
• Protocollo di forwarding da connessioni in ingresso a connessioni in uscita
Porte d’ingresso
Lo schema qui sotto rappresenta una visualizzazione dettagliata delle funzionalità della porta
d’ingresso:
Il modulo di ricerca e inoltro è determinante nella funzionalità del router; è qui che, in molti casi,
viene determinata la porta di uscita dei pacchetti, utilizzando le informazioni della tabella di inoltro.
Sebbene tale tabella sia elaborata dal processore di instradamento una sua copia è presente in ogni
porta d’ingresso. Questo tipo di inoltro, definito inoltro decentralizzato, evita di creare un collo di
bottiglia in un singolo punto all’interno del router.
Se le porte d’ingresso hanno ridotta capacità di elaborazione si limiteranno a inoltrare il pacchetto al
processore d’instradamento.
Una volta determinata la porta di uscita il pacchetto può essere inoltrato alla struttura di
commutazione, sempre che il dispositivo non sia già occupato. In questo caso il pacchetto verrà
accodato nella porta d’ingresso e quindi schedulato per attraversare la struttura di commutazione in
un momento successivo.
Struttura di commutazione
In questa struttura i pacchetti vengono inoltrati dalla porta d’ingresso alla porta di uscita.
La commutazione può essere ottenuta in vari modi:
y Commutazione in memoria
Erano i primi e più semplici router. Le porte di ingresso e di uscita funzionano come
105
Architettura
tradizionali dispositivi di I/O. Quando arriva un pacchetto la porta ne segnala l’arrivo alla
CPU tramite un interrupt e quindi avviene la copia in memoria; la CPU provvedeva a
estrarre l’indirizzo e a fare il confronto con la tabella di inoltro per inviarlo alla porta di
uscita corretta.
y
Commutazione tramite bus
le porte d’ingresso trasferiscono un pacchetto direttamente alle porte di uscita su un bus
condiviso senza intervento da parte del processore di instradamento. Dato che il bus di
trasferimento è condiviso è possibile effettuare una sola trasmissione alla volta; i pacchetti
che trovano il bus occupato attendono nel buffer della porta d’ingresso.
La larghezza di banda ottenuta è limitata da quella del bus
y
Commutazione attraverso rete d’interconnessione
L’utilizzo di una rete di interconnessione permette di superare il limite dovuto a un singolo
bus condiviso.
Un crossbar switch è una rete di interconnessione che consiste di 2n bus che collegano n
porte d’ingresso e n porte d’uscita.
Il pacchetto che giunge a una porta d’ingresso viaggia lungo il bus orizzontale collegato a
tale porta fino a intersecare il bus verticale e, se questo è disponibile, viene trasferito alla
porta d’uscita; se il bus è impegnato a trasferire un pacchetto da una porta d’ingresso alla
stessa porta di uscita, il pacchetto viene inserito nel buffer della porta d’ingresso.
106
Porte d’uscita
L’elaborazione delle porte d’uscita consiste nel prendere i pacchetti dal buffer di uscita e
trasmetterli sul collegamento.
Le funzionalità di accodamento e gestione del buffer sono richieste quando la struttura di
commutazione consegna i pacchetti alla porta di uscita a una frequenza superiore a quella del
collegamento uscente.
Protocollo IP (20 / 2 / 2007)
Lo strato di rete è formato da diversi protocolli. Il primo è il protocollo IP, il secondo è il protocollo
d’instradamento e l’ultimo è il protocollo ICMP.
Ricordo che un pacchetto a livello di rete viene definito datagramma.
Formato del datagramma IPv4:
107
Architettura
y
y
y
y
y
y
y
y
y
y
108
Numero di versione.
questi 4 bit specificano la versione del protocollo IP in modo che i datagramma possano
essere interpretati correttamente
Lunghezza dell’intestazione
Un datagramma IPv4 può contenere un numero variabile di opzioni incluse nell’intestazione
e questi 4 bit indicano dove iniziano effettivamente i dati del datagramma. Il tipico
datagramma IP ha un’intestazione di 20 byte.
Tipo di servizio
questi bit sono stati introdotti per distinguere i diversi tipi di datagramma (ad esempio quelli
che richiedono basso ritardo, alto throughput o affidabilità)
Lunghezza del datagramma
rappresenta la lunghezza totale del datagramma IP, misurata in byte. Questo campo è lungo
16 bit quindi la massima dimensione dei databgrammi IP è 65535 byte anche se raramente
superano i 1500 byte
Identificatore, flag, spiazzamento di frammentazione
Questi 3 campi hanno a che fare con la cosiddetta frammentazione di un datagramma in più
datagramma per superare link con capacità ridotta
Tempo di vita
Time to live (TTL) è stato incluso per evitare che i datagramma non restino in circolazione
per sempre nella rete. Questo campo viene decrementato a ogni passaggio da un router e
quando raggiunge zero il datagramma deve essere eliminato
Protocollo
è usato solo quando il datagramma raggiunge la destinazione finale per indicare a quale
protocollo di trasporto vanno passati i dati (ad esempio se il campo ha valore 6 i dati vanno
passati a TCP, mentre se il campo ha valore 17 i dati sono destinati a UDP)
Checksum dell’intestazione
consente ai router di rilevare errori sui bit contenuti nell’intestazione del datagramma IP
Indirizzi IP d’origine e destinazione
Opzioni
consentono di estendere l’intestazione IP
y
Dati
contiene il segmento a livello di trasporto
Frammentazione dei datagramma IP
Non tutti i protocolli a livello di link possono trasportare pacchetti della stessa dimensione di quelli
a livello di rete.
La massima quantità di dati che un frame a livello di link può trasportare è detta unità massima di
trasmissione (MTU, maximum transmission unit). Dato che per il trasporto i datagramma IP sono
incapsulati in frame a livello di link, la MTU di questo protocollo pone un limite rigido alla
lunghezza dei datagrammi IP. Tale limite non è un problema in sé ma la difficoltà sta nel fatto che il
percorso tra mittente e destinatario può avere tratte con MTU differenti..
La soluzione consiste nel frammentare i datagramma IP in due o più datagramma più piccoli, detti
frammenti. I frammenti dovranno essere riassemblati prima di essere passati a protocolli del livello
di trasporto.
I campi identificazione, flasg e spiazzamento di frammentazione dell’intestazione del databgrammi
IP servono a questo scopo.
Quando crea un datagramma l’host lo contrassegna con un numero identificativo e con gli indirizzi
di origine e destinazione; naturalmente l’host d’invio incrementa l’identificativo per ogni
datagramma che invia.
Quando il router frammenta il datagramma, contrassegna i frammenti con gli indirizzi d’origine e
destinazione e con l’identificatore numerico del datagramma originario. A destinazione verranno
esaminati gli identificatori per determinare i frammenti di uno stesso datagramma. Poiché IP
fornisce un servizio non affidabile alcuni datagramma potrebbero non giungere a destinazione per
questo motivo il campo flag è impostato a 1 per tutti i frammenti tranne nell’ultimo frammento che
è impostato a 1. Il campo spiazzamento viene utilizzato per specificare l’esatto ordine che i
frammenti avevano nel datagramma originale.
Se qualche frammento non arriva a destinazione, il datagramma incompleto viene scartato.
109
Architettura
Indirizzamento IPv4
Generalmente un host ha un solo collegamento con la rete: quando l?IP dell’host vuole inviare un
datagramma, lo fa su tale collegamento. Il confine tra host e collegamento fisico viene detto
interfaccia. Il router presenta più interfacce, ciascuna su ognuno dei suoi collegamenti. Poiché ogni
host e ogni router sono in grado d’inviare e ricevere datagrammi, IP richiede che tutte le interfacce
abbiano un indirizzo IP.
Gli indirizzi IP sono lunghi 32 bit (4 byte) e quindi ci sono in totale 232 indirizzi IP. Tali indirizzi
sono solitamente scritti nella cosiddetta notazione decimale puntata (dotted – decimal notation) in
cui ciascun byte dell’indirizzo viene indicato in forma decimale ed è separato con un punto dagli
altri byte dell’indirizzo.
Concettualmente l'indirizzo IP si compone di due parti:
1. identificatore di rete e precisamente della sottorete
2. identificatore di host
È detta sottorete una rete isolata i cui punti terminali sono collegati all’interfaccia di un host o di un
router.
110
La comunicazione tra i router avviene mediante indirizzi IP utilizzando delle tecniche particolari di
indirizzamento per individuare la sottorete e l'host.
Originariamente lo schema delle suddivisione delle due componenti era a classi per cui un indirizzo
IP aveva una delle seguenti forme:
Con questi schemi l'indirizzo è ad autoidentificazione perché il confine tra le due componenti si può
determinare con i bit più significativi.
y
y
y
y
classe A: il primo byte rappresenta la rete, gli altri l'host; [0-127].x.x.x. La maschera di
sottorete è 255.0.0.0, o /8. Questi indirizzi iniziano tutti con un bit a 0.
classe B: i primi due byte rappresentano la rete, gli altri l'host; [128-191].y.x.x (gli y sono
parte dell'indirizzo di rete, gli x dell'indirizzo di host). La maschera di sottorete è
255.255.0.0, o /16. Questi indirizzi iniziano con la sequenza 10
classe C: i primi 3 byte rappresentano la rete, gli altri l'host; [192-223].y.y.x. La maschera di
sottorete è 255.255.255.0, o /24. Questi indirizzi iniziano con la sequenza 110
classe D: riservata agli indirizzi multicast: [224-255].x.x.x
Classe Leading bits Totale Numero di Reti Numero Max di Indirizzi Host
Classe A 0
127
16.777.214
Classe B 10
16.384
65.534
Classe C 110
2.097.152
254
Bisogna tener presente che gli indirizzi non vengono usati tutti, perché alcuni sono riservati a un
particolare utilizzo (ad esempio gli indirizzi 0.0.0.0, 255.255.255.255, 192.0.34.166 e la classe
192.168.0.1/16) e perché certe classi non vengono sfruttate interamente per via della suddivisione
interna in classi più piccole.
L'indirizzamento a classi, proprio per questo, presenta diversi limiti dovuti soprattutto al numero di
host gestibili dalle diverse classi.
In pratica se si esauriscono gli indirizzi univoci resi disponibili da una classe, ad esempio la C
connettendo più di 255 host, occorre fare ricorso ad un indirizzo di classe superiore.
L'indicatore di rete univoco non poteva adempiere alle esigenze della crescita che negli anni '80
ebbero le reti LAN. Quindi per risparmiare i prefissi di rete si dovettero escogitare altre tecniche
come quella del mascheramento
111
Architettura
Alcuni indirizzi sono riservati per usi speciali
Addresses
0.0.0.0 - 0.255.255.255
10.0.0.0 - 10.255.255.255
CIDR
0.0.0.0/8
10.0.0.0/8
127.0.0.0 - 127.255.255.255 127.0.0.0/8
Funzione
Indirizzi zero
IP privati
Localhost Loopback
Address
169.254.0.0 169.254.0.0/16 Zeroconf
169.254.255.255
172.16.0.0 - 172.31.255.255 172.16.0.0/12 IP privati
Documentation and
192.0.2.0 - 192.0.2.255
192.0.2.0/24
Examples
192.88.99.0 - 192.88.99.255 192.88.99.0/24 IPv6 to IPv4 relay Anycast
192.168.0.0 192.168.0.0/16 IP privati
192.168.255.255
198.18.0.0 - 198.19.255.255 198.18.0.0/15 Network Device Benchmark
224.0.0.0 - 239.255.255.255 224.0.0.0/4
Multicast
240.0.0.0 - 255.255.255.255 240.0.0.0/4
Riservato
A
A
Totale #
indirizzi
16.777.216
16.777.216
A
16.777.216
B
65.536
B
1.048.576
C
256
C
256
B
65.536
C
D
E
131.072
268.435.456
268.435.456
Classe
L'indirizzamento in classi è considerato obsoleto, e per permettere un migliore sfruttamento degli
indirizzi IP disponibili, è stato introdotto l'indirizzamento senza classi, o CIDR (Classless
Interdomain Routine).
La modifica introdotta dal CIDR consiste essenzialmente nell'utilizzare maschere di sottorete
(subnet mask) di lunghezza arbitraria, mentre l'indirizzamento con classi ammetteva solo tre
lunghezze della maschera di sottorete: /8, /16 e /24 (ricordo che questi valori indicano il numero di
bit che rappresenta l’indirizzo della sottorete, i rimanenti bit per arrivare al totale di 32
rappresentano l’indirizzo specifico dell’host all’interno della sottorete). La maschera della vecchia
classe C (/24) è ancora popolare, ma si usano anche maschere più corte per reti grandi (/23 o /22) o
più lunghe per reti piccole (/25, /26, fino a /30 per reti punto-punto).
I bit che nella maschera di sottorete sono a 1 fanno parte dell'indirizzo della sottorete, gli altri sono
l'indirizzo dell'host. Normalmente, la maschera di sottorete è costituita da N bit a 1 seguiti da (32N) bit a 0, e può essere abbreviata nella forma /N.
Come ottenere un blocco di indirizzi
Per ottenere un blocco di indirizzi da usare in una sottorete bisogna contattare il proprio ISP. Lo
stesso ISP, a sua volta, chiederà all’autorità globale che gestisce lo spazio di indirizzamento IP: la
ICANN (Internet Corporation for Assigned Names and Numbers) che ha anche il compito di gestire
i server radice DNS. La ICANN allocherà gli indirizzi ai registri Internet Regionali (ARIN,
RIPE,…) i quali si occupano dell’allocazione della gestione degli indirizzi all’interno delle
rispettive regioni.
Come ottenere l’indirizzo di un host
Un’organizzazione che ha ottenuto un blocco di indirizzi li può assegnare individualmente alle
interfacce di host e router nella propria struttura. La configurazione delle interfacce dei router
avviene manualmente, mentre per assegnare un indirizzo IP ad un host esistono due modi:
y Configurazione manuale: l’amministratore di sistema configura manualmente l’indirizzo IP
dell’host
y Donami Host Configuration Protocol (DHCP): permette a un host di ottenere un indirizzo IP
in modo automatico, così come apprende le informazioni riguardanti alla subnet mask e
112
all’indirizzo del router di primo hop (spesso il gateway) oltre al suo server locale DNS.
DHCP viene spesso detto protocollo plug & play per la sua capacità di automatizzare la
connessione degli host alla rete.
La proliferazione di sottoreti small office, home office (SOHO), sembrerebbe implicare che ogni
volta che una di queste vuole installare una rete locale per connettere più macchine, l’ISP debba
allocare un intervallo di indirizzi per coprire tutte le macchine della sottorete. Per risolvere i
problemi legati a questa situazione viene utilizzata la traduzione degli indirizzi di rete (NAT –
Network Address Translation).
Il NAT è una tecnica che consiste nel modificare gli indirizzi IP dei pacchetti in transito su un
sistema.
Il sistema NAT viene applicato a router che hanno collegamenti verso l’internet globale e verso una
rete locale LAN. I pacchetti che sono destinati a un host sulla rete Internet non possono avere come
indirizzo sorgente quello di una rete locale. Per risolvere questo programma è stato sviluppato il
sistema NAT.
I router abilitati alla NAT non appaiono esattamente come router ma si comportano come un unico
dispositivo con un unico indirizzo IP.
I router NAT, appena riceve un datagramma IP destinato a Internet e non alla rete locale, sfrutta
l’indirizzo di porta sorgente e l’indirizzo IP sorgente per memorizzare il riferimento del pacchetto
nella tabella di traduzione e successivamente cambia l’indirizzo IP sorgente nel suo stesso indirizzo
IP inserendo un riferimento di porta “fasullo” (la porta non deve essere già usata). Nella tabella di
traduzione l’indirizzo IP con la porta fasulla sarà riferito a uno e un solo host nella rete interna.
Quando un pacchetto arriva dalla rete globale con un determinato indirizzo IP e con una
determinata porta l’indirizzo viene modificato in quello corrispondente per instradare correttamente
il pacchetto all’host destinatario.
Il NAT non è ben visto dai puristi delle reti, in quanto mina profondamente la semplicità di IP, e in
particolare viola il principio della comunicazione "da qualsiasi host a qualsiasi host" (any to any).
Questa critica "filosofica" si ripercuote in conseguenze pratiche:
y
y
Le configurazioni NAT possono diventare molto complesse e di difficile comprensione.
L'apparato che effettua il NAT ha bisogno di mantenere in memoria lo stato delle
connessioni attive in ciascun momento. Questo a sua volta viola un principio insito nella
113
Architettura
y
progettazione di IP, per cui i router non devono mantenere uno stato relativo al traffico che
li attraversa.
o Possono essere necessarie grandi quantità di memoria sul router
Alcune applicazioni inseriscono dati al livello IP o TCP/UDP. Questo rende difficile
attraversare un NAT, ed è necessario che il dispositivo NAT analizzi il traffico di controllo
riscrivendo queste informazioni
Protocollo ICMP (Internet Control Message Protocol)
È usato da host è router per comunicare informazioni a livello di rete:
y error reporting
y echo/request/reply (usato da ping)
I messaggi ICMP sono trasportati da datagrammi IP
IPv6 (20 / 2 / 2007)
La progettazione del successore di IPv4, per l’appunto IPv6, è iniziata a causa della diminuzione
dello spazio di indirizzamento IP.
Data l’esperienza acquisita con IPv4 e ben note tutte le problematiche gli sviluppatori apportarono
anche altre modifiche oltre alla struttura degli indirizzi IP.
L’header del datagramma IPv6 è molto differente da quella di IPv4. I principali cambiamenti sono:
y indirizzo Ipv6 a 128 bit rappresentati come 8 gruppi di 4 cifre esadecimale
y intestazione con lunghezza fissa a 40 byte. Una serie di campi IPv4 sono stati resi opzionali;
una intestazione con dimensione ridotta permette una elaborazione più rapida
y etichetta di flusso. Identifica datagrammi nello stesso “flusso”
y Next header (intestazione successiva). Identifica il protocollo dello strato superiore a cui
vanno passati i dati
Nell’intestazione IPv6 è stata rimossa la checksum e non è più possibile la frammentazione del
datagramma; se un router non può trasferire il datagramma sul link di uscita non fa altro che
eliminarlo e inviare un messaggio ICMP “pacchetto troppo grande”. Il campo opzioni non fa più
parte dell’intestazione ma può far parte del campo dati.
Il passaggio da IPv4 a IPv6 è assai complicato, e forse per questo motivo non è ancora stato fatto,
perché i sistemi IPv6 sono retrocompatibili con IPv4 ma i router e i sistemi esistenti non riescono a
elaborare i datagrammi IPv6.
Le soluzioni sono diverse tra cui quella di spegnere tutti i router del mondo e aggiornarli a IPv6, ma
è una cosa improponibile (era già stato fatto in precedenza per il passaggio a TCP).
Probabilmente un approccio più pratico consiste nel metodo a doppia pila che prevede
l’implementazione di un nodo capace di elaborare tutte e due le versioni di IP e permetterne l’invio
dei datagrammi sui link riuscendo a distinguere i nodi IPv4 dai nodi IPv6 e, cosa più importante,
disporre di indirizzi IP validi per entrambi i protocolli.
114
Un’altra soluzione è rappresentata da tunneling.
Supponiamo che due host vogliano inviare e ricevere dati e che questi host utilizzino IPv6 e che
router intermedi utilizzino IPv4 quindi l’ultimo router che, dal lato di invio, è capace di elaborare
IPv6 inserirà il datagramma IPv6 in uno o più datagrammi IPv4 per effettuare il trasferimento,
questo router si trova, quindi, all’inizio del tunnel. Il router posto alla fine del tunnel identificherà
che i datagrammi IPv4 contengono, in realtà, un datagramma IPv6, che verrà ricomposto e inviato
come normale datagramma IPv6.
L’adozione, da parte della rete globale, di IPv6 richiederà molto tempo, ma questo potrebbe
determinare lo standard futuro.
Algoritmi di routing (26 – 27 / 2 / 2007)
Il compito degli algoritmi di instradamento è quello di determinare il percorso a costo minimo tra i
router.
Per formulare i problemi di instradamento si usa generalmente un grafo. Ogni nodo del grafo
corrisponde a un router o ogni lato di un grafo corrisponde a link tra due router; il lato del grafo è
caratterizzato dall’avere un valore che ne identifica il costo. Il costo di un link può essere
determinato, ad esempio, in base alla lunghezza del collegamento stesso.
115
Architettura
Un nodo si dice adiacente (o vicino) ad un altro nodo se i due nodi sono direttamente collegati
tramite un lato del grafo.
Il percorso a costo minimo rappresenta anche il cammino più breve, cioè il cammino con il minor
numero di collegamenti tra l’origine e la destinazione.
Generalmente gli algoritmi d’instradamento possono essere classificati in 2 categorie:
y Algoritmi di instradamento globale. Calcolano il cammino a costo minimo avendo una
conoscenza globale di tutti i router e di tutti i link della rete. Questi algoritmi vengono detti
algoritmi a stato del collegamento (Link State – LS).
y Algoritmi di instradamento decentralizzato. Il cammino a costo minimo viene calcolato
in modo distributivo e iterativo. Nessun nodo possiede le informazioni complete sulla rete.
Questi algoritmi vengono detti distance – vector (DV)
Algoritmo Link State (LS)
Ciascun nodo invia pacchetti di stato del collegamento a tutti gli altri nodi della rete.
L’algoritmo tipico è l’algoritmo di Dijkstra.
1
inizializzazione:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
N’ = {u}
per tutti i nodi v
se v è adiacente a u
allora D(v) = c(u,v)
altrimenti D(v) = ∞
Ciclo
determina un w non in N’ tale che D(w) sia minimo
aggiungi w a N’
aggiorna D(v) per ciascun nodo v adiacente a w e non in N’:
D(v) = min ((D(v), D(w) + c(w,v))
/* il nuovo costo verso v è il vecchio costo verso v oppure il costo
del cammino minimo noto verso w più il costo da w a v */
Finché N’ = N
Dove con D(v) si intende il costo minimo del cammino dal nodo origine alla destinazione v, con
p(v) si intende l’immediato predecessore di v lungo il cammino a costo minimo e con N’
indichiamo il sottoinsieme di nodi che contiene tutti (e solo) i nodi v per cui il cammino a costo
minimo dall’origine a v è definitivamente noto.
Per un esempio dettagliato sull’algoritmo rimando a pag.: 305 – 307 del libro di testo del corso di
Architettura 2.
Algoritmo Distance vector (DV)
L’algoritmo con vettore di distanza è iterativo, asincrono e distributivo.
116
È distributivo nel senso che ciascun nodo riceve parte dell’informazione da uno o più dei suoi vicini
direttamente connessi cui, dopo aver effettuato il calcolo, restituisce i risultati. È iterativo nel senso
che questo processo si ripete fino a quando non avviene ulteriore scambio tra i vicini. L’algoritmo è
asincrono nel senso che non richiede che tutti i nodi operino al passo con gli altri.
Sia dx(y) il costo del percorso minimo da nodo x al nodo y. Allora i costi minimi sono correlati
dalla formula di Bellman – Ford:
d x ( y ) = min v {c( x, y ) + d v ( y )}
1
inizializzazione:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
per tutte le destinazioni y in N:
Dx(y) = c(x, y) /*se y non è adiacente, allora c(x, y) = ∞ */
per ciascun vicino w
Dx(y) = ∞ per tutte le destinazioni y in N
Per ciascun vicino w
Invia il vettore distanza Dx = [Dx(y): y in N] a w
Ciclo
attenti (finché vedi cambiare il costo di un collegamento verso
qualche vicino w o finché richiedi un vettore distanza da
qualche vicino w)
per ogni y in N:
Dx(y) = minv {c(x,y) + Dv(y)}
Se Dx(y) è cambiato per qualche destinazione y
Invia il vettore distanza Dx = [Dx(y): y in N] a tutti i vicini
continua
L’algoritmo DV è decentralizzato perché non usa informazioni globali sulla rete ma solo le
informazioni ottenute dai vicini direttamente connessi al nodo in questione.
L’algoritmo DV viene usato in molti protocolli reali d’instradamento tra cui RIP e BGP.
Le “buone notizie” sul costo di un collegamento si propagano velocemente tra i vari nodi che
modificano in breve tempo (nel giro di 2 iterazioni dell’algoritmo) le proprie tabelle di inoltro. Al
contrario un aumento del costo di un link causerà un instradamento ciclico tra due (o più nodi) che
si continueranno a inviare a vicenda gli stessi pacchetti che devono instradare al nodo per cui il link
è aumentato di costo. In questo modo il cambiamento del costo del link ci metterà molto più tempo
per far si che i router cambino la loro tabella di instradamento. Per risolvere il problema appena
descritto si utilizza l’aggiunta dell’inversione avvelenata (poisoned reverse).
Gli algoritmi LS e DV sono gli unici algoritmi di instradamento utilizzati nell’odierna Internet.
Routing gerarchico
Come ben si sa Internet è una rete di reti e quindi tutti i router non possono possedere informazioni
su tutti i migliaia di router esistenti (nel caso di LS) e non possono pretendere di comunicare con
tutti i router vicini (caso DV).
Questo problema che rende inutilizzabili gli algoritmi LS e DV su larga scala ha portato la
suddivisione di Internet in Auotonomous System (AS) che sono generalmente composti da gruppi
posti sotto lo stesso controllo amministrativo (ISP). I router di uno stesso AS utilizzano lo stesso
algoritmo di instradamento e gli uni hanno informazioni sugli altri.
117
Architettura
Ogni AS è connesso ad altri AS mediante i cosiddetti router gateway.
Per gestire l’instradamento di pacchetti tra gli AS viene utilizzato un unico protocollo chiamato
BGP (Border Gateway Protocol) (di cui parleremo più avanti).
Protocolli di instradamento intra-AS
I protocolli usati per il routing all’interno di un medesimo AS sono due:
y RIP – Routing Information Protocol
y OSPF – Open Shortest Path First
RIP è un protocollo di tipo distance vector. Come costo, il protocollo RIP, utilizza il numero di hop
(salti), in altre parole tutti i collegamenti hanno costo unitario. Il costo massimo di un percorso è
limitato a 15.
In RIP ogni router si scambia messaggi di aggiornamento ogni 30 secondi tramite messaggi
denominati RIP advertisement.
OSPF è stato concepito come successore di RIP. Questo protocollo utilizza l’algoritmo di Dijkstra
per la determinazione del percorso a costo minimo e utilizza il flooding (inondazione) di
informazioni di stato del collegamento.
I costi dei collegamenti vengono fissati dall’amministratore e possono essere tutti a 1, e di
conseguenza avrò una situazione simile a RIP basata sul numero di hop, oppure possono essere
inversamente proporzionali alla capacità del collegamento.
Ogni qual volta di verifica un cambiamento dello stato del collegamento il router manda
informazioni d’instradamento via broadcast a tutti gli altri router; inoltre viene aggiornato
periodicamente lo stato dei collegamenti (almeno ogni 30 minuti) anche se questo non è cambiato.
Gli annunci OSPF sono contenuti in messaggi OSPD che vengono trasportati direttamente da IP.
OSPF, inoltre, controlla che i collegamenti siano attivi tramite un messaggio detto di Hello.
OSPF implementa un meccanismo di autenticazione dei messaggi scambiati tra i vari router.
Instradamento tra sistemi autonomi (AS)
118
Il Border Gateway Protocol (BGP) rappresenta l’attuale standard dei protocolli di instradamento tra
sistemi autonomi; il protocollo BGP fornisce a ciascun AS un modo per:
1. ottenere informazioni sulla raggiungibilità delle sottoreti da parte dei sistemi confinanti
2. propagare le informazioni di raggiungibilità a tutti i router interni a un AS
3. determinare percorsi “buoni” verso le sottoreti sulla base delle informazioni di
raggiungibilità e delle politiche del sistema autonomo.
In particolare BGP consente a ciascuna sottorete di comunicare la propria esistenza al resto di
Internet.
“BGP è un protocollo critico per Internet, sostanzialmente è il protocollo che tiene assieme il tutto.”
In BGP coppie di router si scambiano informazioni d’instradamento su connessioni TCP semi –
permanenti usando la porta 179. Generalmente, in BGP c’è una connessione TCP di questo tipo per
ciascun collegamento che connette direttamente due router in diversi sistemi autonomi.
Esistono anche connessioni TCP semi – permanenti tra router interni ai sistemi autonomi.
I router ai capi di una connessione TCP sono chiamati peer BGP, e la connessione TCP con tutti i
messaggi BGP che vi vengono inviati è detta sessione BGP. Nel caso in cui questa coinvolga due
AS viene detta sessione BGP esterna (eBGP), mentre quella tra router dello stesso AS è chiamata
sessione BGP interna (iBGP).
Le destinazioni, in BGP, non sono host ma prefissi CIDR che rappresentano una sottorete o una
collezione di sottoreti. I router utilizzano il confronto a prefisso più lungo per inoltrare i
datagrammi.
Quando un AS annuncia un prefisso a un altro, sta in realtà promettendo che inoltrerà i datagrammi
su un percorso verso il prefisso cui sono destinati.
Quando un gateway di un qualsiasi AS riceve prefissi appresi tramite eBGP, utilizza le proprie
sessioni iBGP per distribuire i prefissi agli altri router dell’AS. Grazie a questo fatto tutti i router e
tutti i gateway dell’AS verranno a conoscenza dei prefissi; i gateway, a loro volta, invieranno i
prefissi ad altri gateway di altri AS.
In BGP, un sistema autonomo viene identificato dal suo numero di sistema autonomo (ASN,
autonomous system number) globalmente univoco. Esistono anche AS che non hanno ASN e questi
vengono chiamati AS stub.
Gli ASN vengono assegnati, come gli indirizzi IP, da ICANN.
Quando un router annuncia un prefisso per una sessione BGP include anche degli attributi BGP.
Un prefisso e i suoi attributi viene detto route (rotta).
Gli attributi più importanti sono:
y AS-PATH. Questo attributo elenca i sistemi autonomi attraverso i quali è passato
l’annuncio del prefisso. I router utilizzano tale attributo per rilevare ed evitare gli annunci
reiterati, inoltre, i router utilizzano l’AS-PATH nella scelta tra più percorsi verso lo stesso
prefisso.
y NEXT-HOP.
Quando un router gateway riceve un annuncio si rotta, utilizza le proprie politiche di importazione
per decidere se accettare o filtrare la rotta e se impostare determinati attributi quali i parametri di
scelta. Le politiche di importazione possono cancellare una rotta perché il sistema autonomo
potrebbe non voler inviare traffico su uno degli AS nell’AS-PATH; oppure un router gateway può
ignorare una rotta perché conosce una via migliore verso lo stesso prefisso.
L’utilizzo di eBGP e iBGP per distribuire le rotte permette ai router di ricavare più di una rotta
verso un determinato prefisso. BGP necessità di una sola possibilità sulla rotta da usare e quindi
119
Architettura
invoca le seguenti regole di eliminazione fino a quando non ottiene una rotta unica per un
determinato prefisso:
y Alle rotte viene assegnato come attributo un valore di preferenza locale, che potrebbe essere
stato impostato direttamente o appreso dal router. Si tratta di una scelta che è lasciata
all’amministratore di rete dell’AS. Si selezionano, quindi, le rotte con i più alti valori di
preferenza locale.
y Tra le rotte con lo stesso valore di preferenza locale si seleziona quella con AS-PATH più
breve.
y Tra le rotte con stesso valore di preferenza locale e stessa lunghezza di AS-PATH si
seleziona quella il cui router di NEXT-HOP è più vicino (quello con percorso a costo
minimo)
y Se rimane ancora più di una rotta il router si basa sugli identificatori BGP
Broadcast e multicast
Con l’instradamento broadcast, il livello di rete offre un servizio di consegna di un pacchetto
spedito da un nodo origine a tutti gli altri nodi nella rete; l’instradamento multicast consente a un
nodo origine di inviare una copia di un pacchetto ad alcuni nodi della rete.
Esistono diverse soluzioni per il broadcast:
y La più semplice è detta unicast a N vie che consiste nell’invio di uno stesso pacchetto a più
destinatari. Questo sistema, però, presenta dei problemi: se il nodo di origine è connesso alla
rete tramite un singolo collegamento, questo sarà attraversato da N copie dello stesso
pacchetto; sarebbe più efficiente inviare una singola copia del pacchetto sul router di primo
hop e quindi delegare al router la copia e l’inoltro dei pacchetti duplicati.
y
120
Un altro problema deriva dal fatto che si da per scontato che gli indirizzi dei destinatari
siano noti al mittente, ma per ottenere questa informazione sarebbero necessari ulteriori
meccanismi del protocollo (quali l’appartenenza a un gruppo di broadcast). Tutto questo
rende più complesso un protocollo che sembrava semplice
La tecnica più ovvia per ottenere il broadcast è basata sul flooding (inondazione), in cui il
nodo origine invia una copia del pacchetto a tutti i propri vicini (tranne a quello da cui ha
ricevuto il pacchetto). Sebbene tale schema sia semplice ed elegante, presenta un difetto
fatale: se nel grafo c’è un ciclo, allora una o più copie di un pacchetto broadcast
continueranno a percorrere quel ciclo indefinitamente.
Questa tecnica è anche detta di flooding incontrollato perché si può verificare un difetto
assai più disastroso di quello spiegato prima: un nodo adiacente a più di due nodi, crea e
inoltra più copie del pacchetto broadcast, che creeranno a loro volta più copie di se stesse e
così via. Questa tempesta di broadcast (broadcast storm), risultato di una moltiplicazione
y
y
senza fine, porterà alla creazione di un numero talmente elevato di pacchetti che la rete
risulterà inutilizzabile.
La tecnica del flooding controllato con numeri di sequenza permette di risolvere il
problema della tempesta di broadcast. Ogni nodo tiene in memoria una tabella con indirizzi
di origine e numero di sequenza di ogni pacchetto così si prevengono che dei pacchetti
duplicati vengano a loro volta copiati e spediti sui collegamenti.
In secondo approccio al flooding controllato è detto inoltro su percorso inverso (RPF o
anche broadcast su percorso inverso [RPB]). Quando un router riceve un pacchetto
broadcast lo trasmette su tutti i collegamenti in uscita (eccetto su quello da cui l’ha ricevuto)
solo se il pacchetto è pervenuto attraverso ilo percorso unicast più breve tra il router e
l’origine, in caso contrario scarta il pacchetto in quanto sa che riceverà, ho ha già ricevuto,
una copia del pacchetto sul collegamento che si trova sul percorso più breve di ritorno al
mittente.
I metodi di flooding controllato evitano le tempeste di broadcast ma non eliminano il
problema dei pacchetti ridondanti.
Un altro approccio consiste nel costruire un albero di copertura. Quando un nodo vuole
spedire un pacchetto broadcast lo spedisce su tutti i collegamenti incidenti all’albero di
copertura e così fa ogni nodo. Gli alberi di copertura evitano broadcast ridondanti. Un nodo
non deve conoscere l’intero albero ma è sufficiente che sappia quali sono i suoi vicini
nell’albero di copertura. Il problema principale di questa tecnica è la costruzione dell’albero
di copertura. Viene definito un nodo centrale; tutti i nodi inoltrano al nodo centrale,
attraverso l’instradamento unicast, il messaggio di adesione che prosegue lungo le
connessioni fino a quando raggiunge un router che già appartiene all’albero di copertura o
arriva al nodo centrale. (approccio basato su un centro)
Il multicast è l’atto di mandare datagrammi a destinazioni multiple con una singola operazione di
trasmissione.
Nella comunicazione multicast si denotano subito due problemi: l’identificazione dei destinatari e il
loro indirizzamento.
Nell’architettura di Internet viene utilizzato un identificatore che rappresenta un gruppo di
destinatari; questo identificatore è dato da un indirizzo IPv4 di classe D. Il gruppo di destinatari
associati a un indirizzo di classe D viene detto gruppo multicast.
Bisogna ricordare che ogni host ha anche un indirizzo IP unicast indipendente dall’indirizzi di
multicast. Per risolvere il problema si utilizza un protocollo apposito denominato IGMP (Internet
Group Management Protocol) che lavora tra un host e il router a cui è direttamente connesso. IGMP
offre agli host il mezzo di informare i router ad essi connessi del fatto che un’applicazione in
esecuzione vuole aderire a uno specifico gruppo multicast. Dato che il raggio di azione di IGMP è
limitato sarà necessario l’utilizzo di un altro protocollo per recapitare i datagrammi multicast alle
rispettive destinazioni.
121
Architettura
IGMP non è un protocollo che opera tra tutti gli host di un gruppo multicast, infatti non esiste
nessun protocollo di appartenenza, a livello di rete, a un gruppo multicast che coinvolga tutti gli
host di quel gruppo; quindi non si può determinare l’identità dei membri del gruppo stesso.
I messaggi IGMP sono direttamente incapsulati in datagrammi IP. I messaggi membership_query
inviati da un router a tutti gli host connessi da un’interfaccia servono a determinare l’insieme di tutti
i gruppi multicast cui gli host su tale interfaccia hanno aderito.
Ogni host può inviare un messaggio IGMP membership_report prima che il router glielo domandi;
questo significa che l’host sta effettuando il join al gruppo multicast.
L’ultimo messaggio IGMP è leave_group. Questo messaggio è, però, opzionale. Il router deduce
che non ci siano host aderenti a un dato gruppo multicast quando non ottiene risposta a un
messaggio membership_query con quel dato indirizzo di gruppo.
Strato di link e strato fisico (27 / 2 / 2007 – 6 / 3 / 2007)
Prima di poter analizzare in dettaglio gli strati di link e fisico bisogna anche fornire una panoramica
sull’accesso alla rete e sui mezzi trasmessivi.
Gli host possono essere connessi alla rete mediante:
y Reti di accesso residenziale
y Reti di accesso istituzionale (scuole, aziende,…)
y Reti di accesso mobile
Nelle reti di accesso residenziale il collegamento può avvenire
y Via modem analogico con velocità fino a 56 Kbps. Il modem utilizza la linea voce del
telefono.
y Via ADSL (Asymmetric Digital Subscriber Line). L’utilizzo di tale linea permette velocità
superiori al modem tradizionale perché la linea telefonica viene suddivisa secondo il
principio FDM in tre bande: la prima tra 50 KHz e 1 MHz è usata per il downstream, la
seconda, tra 4 e 50 KHz, è usata per l’upstream e, in fine, la terza viene usata per il trasporto
della voce per il telefono (tra 0 e 4 KHz).
Nelle reti di accesso istituzionale viene utilizzata la LAN (Local Area Network); al giorno d’oggi la
LAN è anche utilizzata in situazioni casalinghe.
La LAN permette di connettere gli host ai router di frontiera. Alla base della LAN c’è la tecnologia
Ethernet (standard 802.3) che fornisce un link condiviso o dedicato per connettere host e router e
velocità dei collegamenti da 10 Mbps a 1 Gbps a seconda del tipo di Ethernet usato.
Le reti wireless vengono utilizzate per l’accesso mobile. Queste reti necessitano di una stazione
base nota come “access point”.
Le reti wireless vengono usate, con gli standard WiFi, per le wireless LAN e per accessi wireless
per le telecomunicazioni in fascia ampia (WAP, GPRS,…)
I mezzi trasmessivi utilizzati si basano su cavi (rame, fibra,…) oppure su trasmissioni radio.
y Twisted Pair (TP)
Sono due fili di rame isolati. Si dividono in due categorie: la categoria 3 è usata per il
tradizionale doppino telefonico e per l’Ethernet a 10 Mbps; la categoria 5 è usata a partire da
Ethernet a 100 Mpbs
y
122
Cavo coassiale
È formato da due conduttori di rame concentrici
y
y
Cavo in fibra ottica
la fibra di vetro trasporta gli impulsi di luce (ogni impulso è un bit), permette velocità
elevate ed ha un basso tasso di errore
Radio
Il segnale viene portato nello spettro elettromagnetico. Risente di ostacoli e caratteristiche
ambientali.
È usato per LAN (2 – 54 Mbps), per comunicazioni di telefonia mobile (3G) e in
comunicazioni satellitari.
Passiamo, ora, alla trattazione sullo strato di link.
Lo strato di link ha la responsabilità di trasferire datagrammi da un nodo al nodo adiacente sopra
un link.
Nello strato di link host e router vengono definiti nodi perché non è importante la loro distinzione,
mentre i canali di comunicazione vengono detti link. A questo livello il pacchetto di trasporto viene
definito frame.
Il frame è trasferito da differenti protocolli di trasferimento su diverse tipologie di link. Ogni
protocollo di link fornisce servizi differenti (ad esempio può non offrire rdt [trasporto affidabile]).
Il datagramma IP viene incapsulato in un frame e viene aggiunta una intestazione, con dimensioni
tipiche di 26 byte (ricordo che le intestazioni TCP e IP sono di 20 byte, mentre l’intestazione UDP è
di 8 byte). I protocolli di link devono gestire l’accesso al canale se questo è condiviso.
L’indirizzo utilizzato a livello di link è differente dall’indirizzo IP (ne parleremo più avanti).
Lo strato di link offre i seguenti servizi:
y Framing
incapsulamento dei datagrammi in frame.
y Accesso al collegamento (link access)
y Consegna affidabile
i protocolli di link garantiscono il trasporto senza errori di ciascun datagramma
y Controllo di flusso
evita che vengano sovraccaricati i buffer del nodo ricevente (con conseguente perdita di
dati)
y Rilevazione degli errori
Gli errori sono causati dall’attenuazione del segnale elettrico o dal rumore elettromagnetico.
Molti protocolli forniscono un servizio di rilevazione errori
y Correzione degli errori
È simile alla rilevazione degli errori, ma in più il nodo ricevente determina il punto preciso
in cui si è verificato l’errore e ne tenta la correzione
y Half-duplex e full-duplex
Nella trasmissione full-duplex gli estremi di un collegamento possono trasmettere
contemporaneamente, mentre non possono farlo in quella half-duplex.
Lo strato di link è implementato negli adattatori (o NIC – Network Interface card). Gli adattatori
sono noti anche come schede di interfaccia di rete (o semplicemente schede di rete).
123
Architettura
L’adattatore è semi-autonomo. Per esempio, può ricevere un frame, determinare se contiene errori
e, in caso affermativo, scartarlo senza notificarlo a nessun altro componente del nodo in cui risiede
(il nodo in cui risiede è detto nodo padre dell’adattatore). Quando riceve un frame, l’adattatore
interromperà il nodo padre solamente se vuole inoltrare un datagramma a un livello superiore della
pila protocollare.
I componenti principali dell’adattatore sono l’interfaccia con il canale dati e l’interfaccia con il
collegamento. L’interfaccia con il canale dati è responsabile della comunicazione con il nodo padre,
mentre l’interfaccia con il collegamento implementa i protocolli dello strato di link.
Tecniche di rilevazione e correzione degli errori
La prima tecnica di rilevazione errori è EDC (Error detection and correction).
Questa tecnica consiste nell’aggiungere dei bit di EDC per la rilevazione di errori.
Questo sistema non è affidabile al 100%. Campi EDC più lunghi permettono una miglior
rilevazione degli errori.
Un’altra tecnica consiste nel controllo di parità (parità check).
La forma più semplice di controllo di parità consiste nell’aggiungere un solo bit di parità ad ogni
gruppo di bit trasmessi. Il valore del bit di parità è scelto in modo che ci sia un numero dispari di bit
1.
Questa tecnica non permette di rilevare un numero pari di errori consecutivi.
La parità bidimensionale consente di rilevare e correggere tutti gli errori sui singoli bit.
In questo caso vengono aggiunti bit di parità per ogni riga e per ogni colonna dello strema di bit
inviato. Utilizzando gli indici di riga e colonna è possibile identificare il bit dove si è verificato
124
l’errore e correggerlo. Con la tecnica della parità bidimensionale è possibile, anche, rilevare e
correggere errori nei bit di parità.
Nonostante tutto questa tecnica non è in grado di rilevare e correggere tutte le possibili
combinazioni di errori.
La 3° tecnica di rilevazione errori consiste nell’utilizzazione della somma di controllo, checksum.
In questo caso il segmento viene trattato come sequenza di interi a 16 bit; questi valori, poi,
vengono sommati e il complemento a 1 della somma costituisce la checksum.
I metodi di cheksum richiedono intestazioni di pacchetto relativamente piccole ma forniscono una
prevenzione dagli errori piuttosto limitata.
La 4° tecnica è la più usata a livello di link ed è il controllo a ridondanza ciclica (CRC, Cyclic
redundancy check).
L’idea base del CRD è la seguente: consideriamo d bit costituenti i dati D da trasmettere e
supponiamo che origine e destinazione si siano accordati su una stringa di r + 1 bit, conosciuta
come generatore, che indicheremo con G. È necessario che il bit più significativo (quello più a
sinistra) di G sia 1. Dato un blocco di dati, D, il mittente sceglierà r bit addizionali, R, e li unirà a D
in modo da ottenere una stringa di d + r bit che, interpretata come numero binario, sia esattamente
divisibile per G (nell’aritmetica modulo 2). Il processo di controllo CRC è semplice: se la divisione
(d + r)/G ha un resto diverso da 0, il ricevente sa che si è verificato un errore, altrimenti i dati sono
accettati come corretti.
Esempio di CRC
125
Architettura
CRC può rilevare errori a raffica inferiori a r + 1 bit; ovvero tutti gli errori consecutivi di non oltre
r bit saranno rilevati.
Protocolli di accesso multiplo
Bisogna tener presente che esistono due tipi di collegamento:
y Collegamento punto – punto: è costituito da un trasmittente, ad un’estremità del
collegamento, ed da un unico ricevente dall’altra. (il protocollo PPP è pensato per questi
link)
y Collegamenti broadcast: può avere più nodi trasmittenti e più nodi riceventi. Il termine
broadcast indica che quando un nodo trasmette frame, il canale lo diffonde a tutti gli altri
nodi, che ne ricevono una copia. Ethernet e Wireless LAN sono esempi di tecnologie a
collegamenti broadcast.
Per i protocolli di accesso multiplo è da ricordare che il link è condiviso e che due o più
trasmissioni simultanee danno luogo a interferenza (collisione), quindi è possibile una sola
trasmissione alla volta.
In generale è possibile suddividere questi protocolli in 3 categorie:
y Protocolli a suddivisione del canale (channel paritioning protocol)
y Protocolli ad accesso casuale (random access protocol)
y Protocolli a rotazione (taking-turn protocol)
126
I protocolli MAC a suddivisione del canale sono 3:
y A divisione di tempo – TDM (Time Division Multiplexing):
il tempo viene suddiviso in intervalli e ciascun intervallo viene suddiviso in slot. Il numero
di slot varia a seconda del numero di nodi.
Ogni slot verrà assegnato a un nodo. Ogni volta che un nodo vuole trasmettere un pacchetto
lo farà solo nello slot di tempo assegnatogli. La banda di trasmissione sarà R/N. Il problema
di questa tecnica sta nel fatto che, anche se nessun nodo sta trasmettendo, un nodo deve
sempre attendere il suo slot di tempo per poter trasmettere.
y A divisione di frequenza – FDM (Frequency Division Multiplexing):
la suddivisione del canale avviene in frequenze differenti, ciascuna con ampiezza di banda
R/N (cioè a partire da un canale di r bps, FDM crea N canali di R/N bps). Ciascuna
frequenza viene assegnata ad un nodo. Questo sistema evita collisioni e divide equamente la
banda disponibile tuttavia la larghezza di banda è limitata a R/N anche quando c’è un solo
nodo che ha un pacchetto da inviare.
y Accesso multiplo a divisione di codice – CDMA (Code Division Multiple Access):
CDMA assegna ad ogni nodo un codice; ogni nodo userà questo codice per codificare i dati
inviati. Se i codici sono scelti accuratamente consentono a nodi differenti di trasmettere
simultaneamente e consentono ai destinatari si ricevere correttamente di bit dei dati
codificati nonostante le interferenze derivate dagli altri nodi
I protocolli MAC ad accesso casuale sono vari e permettono ad un nodo di utilizzare la massima
ampiezza disponibile del link, il problema deriva dalle collisioni.
Il protocollo più semplice è lo Slotted ALOHA.
Ipotesi
y tutti i frame stessa della dimensione
y tempo è diviso in slot di uguale dimensione, tempo per trasmettere 1 frame
y nodi iniziano a trasmettere frame solo all’inizio degli slot
y nodi sono sincronizzati
y se 2 o più nodi trasmettono nello stesso slot, tutti i nodi rilevano la collisione
Operazione
y quando un nodo riceve un nuovo frame, esso trasmette nello slot successivo
y niente collisione, il nodo può inviare nuovo frame nello slot successivo
y se collisione, nodo ritrasmette frame in ogni slot successivo con probabilità p fino al
successo
Il vantaggio principale deriva dal fatto che un singolo nodo attivo può trasmettere continuamente al
tasso totale del link. Gli svantaggi derivano dallo spreco di slot dovuto alle collisioni.
L’efficienza è la frazione (sul lungo periodo) di slot con successo quando ci sono molti nodi,
ognuno con molti frame da inviare.
127
Architettura
La probabilità che ogni nodo abbia successo è Np (1 − p ) N −1 dove N è il numero di nodi e p è la
probabilità dello slot.
Con lo slotted ALOHA ho un utilizzo utile del canale del 37%
Il primo protocollo ALOHA puro era privo di slot. Un nodo trasmetteva immediatamente e
integralmente il pacchetto nel canale broadcast. Se un pacchetto va in collisione il nodo lo
ritrasmette immediatamente. Con questo sistema aumentano le collisioni e il successo di un dato
nodo è calcolabile con la formula p (1 − p )2( N −1) .
Nel caso peggiore l’utilizzazione del canale è al 18%.
Un altro protocollo ad accesso casuale è CSMA (Carrier Sense Multiple Access) cioè accesso
multiplo a rilevazione della portante.
Le regole alla base dei protocolli CSMA e CSMA/CD (CSMA with collision detection) sono:
y Ascoltare prima parlare cioè la rilevazione della portante (carrier sensing). Un nodo ascolta
il canale. Se il canale sta già trasmettendo allora il nodo attende un tempo casuale e riascolta
nuovamente il canale. Se il canale è libero inizia la trasmissione altrimenti attende
nuovamente e ripete il processo.
un nodo rimane in ascolto per 96 bit di tempo cioè per il tempo che occorre ad inviare 96 bit
sul link
y Se qualcun altro comincia a parlare insieme a voi, smettete di trasmettere cioè la rilevazione
della collisione (collision detection).
Per capire il funzionamento di CSMA e CSM/CD utilizzerò un esempio:
Questo primo grafico rappresenta il funzionamento del protocollo CSMA.
All’istante t0 il nodo B rileva che il canale è inattivo e comincia la trasmissione, e i suoi bit si
propagano in entrambe le direzioni lungo il mezzo. La propagazione verso valle dei bit di B al
crescere del tempo indica che è necessario un intervallo di tempo non nullo per l’effettiva
propagazione dei bit di B lungo il canale (benché questa avvenga alla velocità della luce). Al tempo
128
t1 > t0, il nodo D ha un pacchetto da spedire. Sebbene al tempo t1 il nodo B stia ancora trasmettendo,
i suoi bit non hanno ancora raggiunto D e quindi, in quell’istante, D ritiene inattivo il canale. Nel
pieno rispetto del protocollo, D cominci a trasmettere i suoi pacchetti. Dopo un breve tempo la
trasmissione di B comincerà ad interferite con quella di D. Dalla figura risulta evidente che il
ritardo di propagazione da un estremo all’altro di un canale broadcast avrà un ruolo cruciale nel
determinare le sue prestazioni. Maggiore sarà questo ritardo, maggiore è la possibilità che il nodo
non si accorga che è già cominciata la trasmissione da parte di un altro nodo.
In questo grafico i nodi non effettuano la rilevazione della collisione.
Cambiamo scenario e introduciamo la rilevazione della collisione:
Quando un nodo rileva la collisione cessa immediatamente di trasmettere. È evidente che
l’introduzione della rilevazione della collisione in un protocollo ad accesso multiplo ne migliorerà
le prestazioni evitando l’inutile ritrasmissione dell’intero pacchetto danneggiato.
Quando avviene una collisione viene generato un segnale di jam che dura 48 bit di tempo per
marcare la collisione in modo che tutti i nodi possano rilevarla. In questo modo si riduce la
probabilità che un nodo abbia già finito di trasmettere il pacchetto prima che venga rilevata la
collisione.
129
Architettura
Indirizzi a livello di link
L’indirizzo fisico o indirizzo MAC (media access control) è differente dall’indirizzo IP utilizzato
dallo strato di rete. L’indirizzo MAC, o MAC address, è lungo 6 byte (48 bit) ed è rappresentato
con cifre esadecimale.
L’indirizzo MAC è permamente e risiede nella ROM dell’adatattatore.
Gli indirizzi MAC vengono assegnati a blocchi dall’IEEE.
Quando un adattatore vuole spedire un pacchetto vi inserisce l’indirizzo MAC di destinazione e lo
immette nella LAN.
L’indirizzo MAC di destinazione non è quello dell’host di destinazione, come accadeva con IP, ma
è l’indirizzo MAC del nodo più vicino cioè quello direttamente collegato al link fisico; sarà il nodo
ad estrarre il datagramma IP e a guardare l’indirizzo IP per capire su quale collegamento inviarlo.
Naturalmente al nuovo invio il datagramma IP viene incapsulato in un frame il cui indirizzo MAC
di destinazione è quello del nodo che sta all’altro capo del link fisico. La figura sottostante mostra
lo scenario di invio di un pacchetto da un host della LAN 1 ad un host della LAN 2.
Anche per quanto riguarda il MAC address esiste un indirizzo di broadcast ed è costituito da 48 bit
con valore 1 (cioè FF-FF-FF-FF-FF-FF).
A questo punto sorge un problema: come fa un nodo a sapere a quale indirizzo MAC corrisponde
un determinato indirizzo IP?
130
Questo problema viene risolto dal protocollo di risoluzione degli indirizzi (ARP – address
resolution protocol).
Ogni adattatore ha in memoria la tabella ARP che contiene la corrispondenza di tutti gli indirizzi IP
della rete a cui è connessa con i rispettivi indirizzi MAC. In aggiunta ha anche una campo TTL
(time to live) che indica quando la corrispondenza indirizzo IP – indirizzo MAC va eliminata e di
conseguenza aggiornata.
Può succedere che la tabella ARP non contenga tutti gli indirizzi MAC di tutti i nodi della rete. Se
un nodo non conosce l’indirizzo MAC di un altro nodo invia un pacchetto ARP in broadcast (il
pacchetto ARP sarà incapsulato in un pacchetto di rete) a tutti i nodi della rete. Il nodo che avrà quel
determinato indirizzo IP di cui si vuole conoscere il corrispettivo indirizzo MAC risponderà con un
pacchetto ARP standard in cui è presente sia l’indirizzo IP che l’indirizzo MAC. Così facendo ARP
può aggiornare la sua tabella.
DHCP (Dynamic Host Configuration Protocol)
Obiettivo: l’host può ottenere dinamicamente il suo indirizzo IP da un server quando si unisce alla
rete.
Può rinnovare il permesso per un indirizzo in uso.
Permesso riuso di indirizzi (gli indirizzi vengono bloccati solo mentre si è connessi)
DHCP generalità:
– messaggi di host broadcast: “DHCP discover” (messaggio inviato con UDP sulla porta 67)
– server DHCP risponde con messaggi “DHCP offer”
– host richiede indirizzo IP: messaggi “DHCP request”
– server DHCP invia indirizzo: messaggi “DHCP ack”
Ethernet
La topologia delle reti Ethernet odierne è a stella, in cui ogni nodo è collegato ad un router centrale.
Ethernet ha una propria struttura dei frame:
un frame Ethernet è formato da:
y Campo dati (da 46 a 1500 byte). Contiene il datagramma IP o di qualunque altro protocollo
usato a livello di rete.
L’unità massima trasferita (MTU) per Ethernet è 1500 byte; qualora il datagramma IP
superasse questo valore verrà frammentato. Se il datagramma IP ha dimensione inferiore a
46 byte verranno aggiunti dei bit “inutili” per arrivare a tale dimensione minima.
y Indirizzo di destinazione (6 byte). Contiene l’indirizzo MAC dell’adattatore di
destinazione. Se il pacchetto è destinato ad un host presente nella stessa LAN in questo
campo ci sarà l’indirizzo MAC dell’host altrimenti sarà inserito l’indirizzo MAC del router
per effettuare il trasferimento del pacchetto sul link esterno.
y Indirizzo sorgente (6 byte). È l’indirizzo MAC dell’host sorgente. Cioè di chi ha creato il
pacchetto
y Campo tipo (2 byte). Consente a Ethernet di supportare vari protocolli di rete. Indica a
quale protocollo sovrastante bisogna passare i dati contenuti nel campo dati.
y Controllo a ridondanza ciclica (4 byte). Questo campo contiene i bit per effettuare il CRC
Check
y Preambolo (8 byte). I pacchetti Ethernet iniziano con un campo di 8 byte; sette byte hanno
bit 10101010 e l’ottavo byte è 10101011. I primi 7 byte del preambolo servono per
131
Architettura
“attivare” gli adattatori dei riceventi e sincronizzare i loro orologi con quello del
trasmittente. Ciò avviene per una precisa ragione: in funzione del tipo di LAN Ethernet,
l’adattatore A cercherà di trasmettere il pacchetto a 10 Mbps, 100 Mbps o 1 Gbps; ma si
verificherà sempre una variazione rispetto all’esatto tasso prefissato, che non è conosciuta a
priori dagli altri adattatori sulla LAN. Quindi, il ricevente può utilizzare i primi sette byte
del preambolo per sincronizzarsi con l’orologio dell’adattatore di A. Gli ultimi due bit
dell’ottavo byte del preambolo (in pratica i due 1 consecutivi) avvisano l’adattatore di B che
i successivi 6 byte sono l’indirizzo di destinazione
Ethernet utilizza la trasmissione in banda base cioè, l’adattatore invia un segnale digitale
direttamente nel canale broadcast. La scheda d’interfaccia non sposta il segnale in un’altra banda di
frequenza, come accade per ADSL.
In Ethernet viene anche usata la codifica Manchester.
Con questa codifica durante la ricezione di ciascun bit si verifica una transizione. Il bit 1 è associato
a una transizione dall’alto verso il basso, e viceversa per il bit 0. Il motivo dell’utilizzo della
codifica Manchester è che gli orologi degli adattatori trasmittenti e riceventi non sono perfettamente
sincronizzati. Inserendo una transizione in ogni bit, l’host ricevente può sincronizzare il suo
orologio con quello dell’host trasmittente. Una volta che l’orologio dell’adattatore è sincronizzato,
il ricevente può inquadrare ciascun bit e determinare se è 1 o 0.
Ethernet utilizza l’algoritmo CSMA/CD per la gestione dell’accesso multiplo.
Quando viene rilevata una collisione viene inviato un segnale di disturbo detto segnale jam che ha
durata di 48 bit di tempo dopodichè l’adattatore entra nel backoff esponenziale: dopo la collisione
m-esima, l’adattatore sceglie un K a caso da {0,1,2,…,2m-1}. L’adattatore aspetta K*512 bit di
tempo prima di rittrasmettere.
L’obiettivo del backoff esponenziale è adattare i tentativi di ritrasmissione alla stima di carico
corrente.
Quando un solo nodo ha un pacchetto da inviare, può trasmettere alla massima velocità consentita
dalla specifica installazione (10 Mbps, 100 Mbps,…). Se, invece, i nodi sono numerosi, l’effettiva
velocità di trasmissione sul mezzo può risultare notevolmente inferiore.
Definiamo efficienza di Ethernet la frazione di tempo media durante la quale i pacchetti sono
trasferiti sul canale senza collisioni in presenza di un ragguardevole numero di nodi attivi con
un’elevata quantità di pacchetti da inviare.
Indichiamo con tprop il tempo massimo che occorre al segnale per propagarsi fra una coppia di
adattatori e con ttrasm il tempo necessario per trasmettere un pacchetto della maggior dimensione
possibile, avremo:
1
efficienza =
t prop
1+ 5⋅
t trasm
132
Dalla formula si evince che quando tprop tenda a 0, l’efficienza tende a 1. Questo conferma l’ipotesi
che quando il ritardo di propagazione è nullo, i noi in cui si verifica una collisione interromperanno
immediatamente la trasmissione senza sprecare il canale. Inoltre al crescere di ttrasm l’efficienza
tenda a 1.
Hub, switch e bridge
y Hub di Backbone interconnette gli spezzoni della LAN
y Estende max distanza tra i nodi
y I domini di collisione dei singoli segmenti diventano un unico dominio di collisione
y Non si possono collegare spezzoni 10BaseT e 100BaseT, nel senso che ad un hub vanno
collegate su tutte le porte lo stesso tipo di tecnologia.
Il bridge
y Dispositivo dello strato di Link
– “store and forward” frame Ethernet
– esamina header frame e selettivamente inoltra frame basati su indirizzi MAC di
destinazione
– quando frame è inoltrato su un segmento, usa CSMA/CD per accedere al segmento
y transparente
– host sono ignari della presenza di bridge
y plug-and-play, self-learning
– bridge non necessitano di essere configurati
y bridge filtrano i pacchetti:
– frame sullo stesso segmento di LAN non sono di solito inoltrati sugli altri segmenti
LAN
– segmenti diventano separati domini di collisione
y può connettere differenti tipi di Ethernet
133
Architettura
Gli switch sono essenzialmente bridge multiporta.
PPP – point to point protocollo
y packet framing: incapsulamento del datagramma dello strato di rete in un frame dello strato
link
– porta dati dello strato di rete per ogni protocollo di quello strato (non solo IP) allo
stesso tempo
– abilità di demultiplazione
y bit transparency: deve portare un qualunque pattern di bit nel campo data
y error detection (niente correzioni)
y connection liveness: rilevare e segnalare “link failure” allo strato di rete
y network layer address negotiation: endpoint possono imparare/configurare gli indirizzi di
rete tra loro
y Recupero da errore, controllo di flusso, ri-ordinamento dei dati sono tutti delegati agli strati
superiori
Multimedialità in rete (12 – 13 / 3 / 2006)
Il problema delle trasmissioni multimediali è la qualità del servizio (QoS).
Le principali applicazioni multimediali sono:
y Streaming audio/video registrato
y Streaming audio/video in diretta
y Audio/video interattivo in tempo reale
Le applicazioni multimediali sono sensibili al ritardo ma sono tolleranti alle perdite.
La variabilità dei ritardi dei pacchetti nello stesso flusso di pacchetti è detta jitter.
Compressione audio
y Segnale analogico campionato a tasso costante
- telefono: 8000 campionamenti/secondo
- cd audio: 44100 campionamenti/secondo
y Ogni campione è quantizzato
- 28 = 256 possibili valori quantizzati
y Ogni valore quantizzato è rappresentato da bit
Esempio:
8000 campionamenti/secondo, 256 valori discreti Æ 64000 bps
Tassi di esempio:
CD: 1,411 Mbps (non compresso)
MP3: 96, 128, 160 Kbps
Telefonia Internet: 5 – 13 Kbps
Compressione video
y Il video è una sequenza di immagini proiettate a tasso costante (ad esempio lo standard PAL
a 24,79 fotogrammi/secondo)
y L’immagine digitale è rappresentata da un array di pixel
y Ogni pixel è rappresentato da bit
Esempi:
MPEG1 (CD-ROM): 1,5 Mbps
MPEG2 (DVD): 3 – 6 Mbps
134
MPEG4: < 1 Mbps
Streaming multimediale registrato
Per poter effettuare lo streaming di contenuti audio/video è necessario spremere a fondo il servizio
“best effort” di Internet e utilizzare tecniche per far si che il bitter non interferisca con la
riproduzione.
Il browser web riceve un metafile che contiene le informazioni sul recupero del file multimediale, il
quale viene passato ad un media player (che può anche essere un plug-in del browser). Sarà il player
a contattare il server per recuperare il file audio/video.
Non vi è l’utilizzo del protocollo http tra il player e il server.
Per l’invio dei pacchetti dello strema audio/video viene utilizzato UDP perché il server può inviare
il file al tasso di trasmissione appropriato ignorando la congestione della rete. UDP, inoltre,
consente un breve ritardo di riproduzione per compensare il jitter e un recupero da errore. Le
trasmissioni sotto TCP sarebbero troppo soggette alla fluttuazione del tasso di trasmissione dovuto
al controllo di congestione.
Il buffer lato client introduce un ritardo sull’inizio della riproduzione dello strema audio/video ma
permette di compensare il jitter e i vari ritardi della rete:
Il server salva e trasmette copie multiple del video codificate a bit-rate differenti per client con
differente banda.
Per la gestione degli stream multimediali è stato sviluppato il protocollo RTSP:
y È un protocollo dello strato di applicazione
y Permette il controllo dello strema da parte dell’utente (rewind, fast forward, play, pause,
repositioning,…)
y Non definisce come l’audio e il video sono incapsulati
y Non da limitazioni su come il media in streaming è trasportato; può essere trasportato su
UDP o TCP
y Non specifica le modalità con cui il player deve bufferizzare lo stream
y È un protocollo out of band come FTP, quindi fa uso di differenti numeri di porta
Multimedia interattivo: telefonia su Internet
y Caratterizzata da periodi di parlato alternati a periodi silenti (64 Kbps durante il parlato)
y I pacchetti vengono generati solo durante i periodi di parlato
- chunk di 20 msec a 8 KB/s = 160 byte di dati
y Ad ogni chunk viene aggiunto un header dello strato di applicazione
y Chunk e header vengono incapsulati in un pacchetto UDP con header tipico
135
Architettura
y
y
y
y
y
y
L’applicazione invierà il segmento UDP ogni 20 msec durante il periodo di parlato
La tolleranza della perdita dei dati dipende dalla codifica utilizzata (in generale una perdita
tra l’1 e il 10% è tollerabile)
La perdita dovuta al ritardo è meno tollerabile perché il pacchetto non può essere riprodotto
se non arriva entro un tempo stabilito. Tipicamente il massimo ritardo tollerabile è 400 msec
Il receiver tenta di riprodurre ogni chunk esattamente q msec dopo che il chunk è stato
generato;
- ogni chunk è dotato di un timestamp
- minore è il tempo q migliore risulta l’interattività
Per minimizzare il ritardo di riproduzione viene utilizzato un ritardo adattativi di
riproduzione
- in base alla stima del ritardo in rete il ritardo di riproduzione viene regolato
- i periodi silenti sono compressi e allungati
- il receiver guarda i timestamp per verificare se è iniziata una sequenza di parlato e per
conoscere l’ordine in cui riprodurre i pacchetti. Se si verifica una perdita di pacchetti il
receiver dovrà anche controllare i numeri di sequenza
Il sistema non si adatta in maniera rapida a variazioni di jitter negative
Forward Error Correction (FEC)
1° schema FEC
y per ogni gruppo di n chunk creato un chunk ridondante con XOR degli n chunk originali
y inviati n+1 chunk, aumentando la bandwidth di un fattore 1/n.
y si possono ricostruire gli n chunk originali se c’è al più un chunk perduto tra gli n+1 chunk
y Ritardo di riproduzione deve essere fissato all’istante di ricezione di tutti gli n+1 pacchetti
y Compromesso:
– aumentando n, meno banda sprecata
– aumentando n, maggiore ritardo di riproduzione
– aumentando n, più alta probabilità che 2 o più chunk siano persi
2° schema FEC – piggyback lower quality stream
y Viene inviato uno stream a minore risoluzione come informazione ridondante
y Quando c’è una perdita non consecutiva, il receiver può mascherare la perdita
Interleaving
y I chunk sono spezzati in unità più piccole
y Un pacchetto contiene unità di chunk differenti
136
y
y
y
Se il pacchetto è perso si ha ancora la maggior parte di ogni chunk
Non ha overhead di ridondanza
Aggiunge ritardo alla riproduzione
Real Time Protocol (RTP)
y RTP specifica una struttura di pacchetto per pacchetti che portano dati audio e video
y RTP fornisce
– identificazione del tipo di payload
– sequenza di numerazione del pacchetto
– timestamping
y RTP è nei sistemi terminali.
y pacchetti RTP sono incapsulati in segmenti UDP
y Interoperabilità: Se due applicazioni di telefono Internet funzionano con RTP, allora
possono essere in grado di lavorare insieme
y Non fornisce indicazione sul tipo di codifica dello stream
y Non fornisce nessun meccanismo che assicuri la consegna o fornisca garanzie sulla qualità
del servizio (QoS)
Header RTP
Payload Type (7 bit): Indica il tipo di codifica che è correntemente usata. Se sender cambia
codifica nel mezzo di una conferenza, sender informa i receiver attraverso questo campo payload
type.
y Payload type 0: PCM mu-law, 64 kbps
y Payload type 3, GSM, 13 kbps
y Payload type 7, LPC, 2.4 kbps
y Payload type 26, Motion JPEG
y Payload type 31. H.261
y Payload type 33, MPEG2 video
Sequence Number (16 bit): Incrementa di uno per ogni pacchetto RTP inviato e può essere usato
per rilevare la perdita di pacchetti e a ripristinare la sequenza di pacchetti.
137
Architettura
Timestamp (32 bit): Riflette l’istante di campionamento del primo byte nel pacchetto dati RTP.
y Per audio, il timestamp tipicamente incrementa di uno per ogni periodo di campionamento
(per esempio, ogni 125 μsec per un clock di campionamento a 8 KHz)
y Se applicazione genera chunk di 160 campioni codificati, allora timestamp aumenta di 160
per ogni pacchetti RTP quando la sorgente è attiva. Timestamp continua ad aumentare ad un
tasso costante quando la sorgente è inattiva.
SSRC (32 bit): Identifica la sorgente dello stream RTP. Ogni stream in una sessione RTP dovrebbe
avere una distinta SSRC.
RTP ha un protocollo associato: RTCP (Real Time Control Protocol) che trasmette informazioni di
controllo (pacchetti inviati, persi, jitter,…). Il feedback può essere usato per controllare le
prestazioni.
I pacchetti RTP e RTCP sono distinti attraverso l’uso di differenti numeri di porta.
RTCP può di sincronizzare stream di differenti media dentro una sessione RTP.
RTCP tenta di limitare il suo traffico al 5% della banda della sessione; di questo 5% il 75% è
riservato ai receiver e il rimanente 25% è riservato ai sender.
SIP (Session Initiation Protocol)
y Tutte chiamate telefoniche e video conferenze possono avere luogo in Internet
y Gente identificata dai nomi o indirizzi e-mail, piuttosto che da numeri di telefono.
y Puoi raggiungere il chiamato, non importa dove, non importa quale dispositivo IP il
chiamato stia usando.
y SIP usa il principio KISS: Keep it simple stupid
y Questo protocollo vuole fornire un vero concetto di mobilità a differenza di DHCP che da
un senso di mobilità
SIP fornisce i seguenti servizi:
y Stabilisce chiamata
– Fornisce meccanismi a chiamante per far sapere a chiamato che vuole stabilire la chiamata
– Fornisce meccanismi in modo che chiamante e chiamato possono accordarsi sul tipo di
media e codifica.
– Fornisce meccanismi per finire la chiamata.
y Determina corrente indirizzo IP del chiamato
– Mappa identificatore mnemonico al corrente indirizzo IP
y Gestione di chiamata
– Aggiunge nuovi stream media durante chiamata
– Cambia codifica durante chiamata
– Invita altri
– Trasferisce e tiene chiamate
Esercitazioni del 28 / 2 / 2007 – 7 / 3 / 2007 – 14 / 3 / 2007
1. In un algoritmo di routing che utilizza una metodologia distance-vector:
– È necessario conoscere la distanza dai router vicini
2. Quando un host lascia un gruppo multicast:
– Non esegue nessuna comunicazione di abbandono
138
3. Durante una connessione TCP, un pacchetto IPv4 in viaggio dall'host A all'host B viene
frammentato in nove parti. Una delle parti, diciamo la settima non arriva a destinazione
all'host B. Che cosa succede?
– Dopo la ricezione di 3 ACK duplicati l’host A rispedisce l’intero pacchetto.
Se manca un frammento di un pacchetto il datagramma viene scartato
4. Se ci sono sei router tra due host, ignorando la frammentazione quante tabelle di routing
saranno utilizzate da un pacchetto che viaggia tra i due host?
–7
Lo schema qui sotto rappresenta la situazione proposta dalla domanda:
La domanda richiede il numero di tabelle di routing. Dallo schema è evidente che ci sarà una tabella
di routing su ogni router (e quindi siamo a quota 6) + una tabella di routing sull’host A per poter
inviare il segmento al primo router
5. Se invio un datagramma di 3000 byte in un link con MTU di 500 byte quanti frammenti
sono generati? Il datagramma originale ha il numero 305 nel campo "identification number".
Assumete un overhead di intestazione tipico.
– 7 frammenti
3000 = 20 + 2980
Per ogni frammento ho 20 byte di intestazione
500 = 20 + 480
Ogni frammento avrà una nuova intestazione IP
3000/500 = 6 normalmente servono 6 frammenti ma devo tener conto che ogni frammento
ha 20 byte di intestazione e che quindi in totale sono 120 byte (20*6) quindi avrò bisogno di
un 7° frammento
6. Se un applicativo genera una sequenza di 40 byte ogni 20ms e ciascuna sequenza viene
incapsulata in un pacchetto TCP e poi in un pacchetto IP quale percentuale del datagramma
ottenuto sarà almeno di overhead?
– 50%
Il tipico overhead IP è 20 byte, come pure l’overhead di TCP.
La dimensione del datagramma è 20 + 20 + 40 = 80 byte
Essendo l’overhead dovuto a IP e TCP (40 byte) è evidente che l’overhead è il 50% del
datagramma
7. Una organizzazione vuole mantenere tutti i suoi client dietro un router NAT su rete privata.
Il router NAT ha una sola uscita su IP pubblica fornita dal ISP dell'organizzazione. Gli
indirizzi privati sono del tipo 10.0.0.0/x. Quanti bit al minimo caratterizzano la rete privata?
–8
I bit che caratterizzano il tipo di rete considerata sono come minimo 8
8. Una organizzazione ha 1600 host a cui deve assegnare un indirizzo IP. Richiede al suo ISP
un blocco di indirizzi della forma a.b.c.d/x in cui x indica il numero di bit che denotano la
parte di rete dell'indirizzo. Quale percentuale di indirizzi rimangono liberi nel blocco
139
Architettura
assegnato?
– 22%
con 10 bit di host posso rappresentare 210 = 1024 possibili indirizzi IP, quindi ho bisogno di
11 bit per poter tener 1600 host
(x = 32 – 11 = 21 bit di rete.)
Il numero di indirizzi IP nel blocco è 211 =2048 – 2 (tra cui l’indirizzo di broacast) = 2046. Il
numero di indirizzi IP liberi è
2046 – 1600 = 446
446
Calcolo la percentuale:
⋅ 100 = 22
2046
9. Arrivate in una organizzazione e vi danno il seguente configurazione per la interfaccia di
rete del vostro calcolatore:
IP: 200.23.10.40
NetMask: 255.255.255.240
Gateway: 200.23.10.33
Quante schede di rete, inclusa la vostra, possono essere configurate su questa lan, esclusa
l'interfaccia del router?
– 13
La maschera fornita mi dice che ho 28 bit di rete e 4 bit per gli host.
Quindi 24 – 2 = 16 host, ma 2 host sono sempre riservati quindi ho 14 host disponibili in
quella sottorete, ma siccome 1 indirizzo è riservato al router posso collegare solo altri 13
host.
1. In uno schema CRC a 32 bit il sender sceglie 32 bit addizionali e li appende al dato originale
per proteggerlo da eventuali errori. Quanti bit avrà il generatore G condiviso?
– 33
Con la scelta r = 32 verranno rilevati tutti gli errori a raffica fino a r + 1 = 32 + 1 = 33 bit.
Entro le appropriate assunzioni la probabilità di rilevare una raffica di errori di lunghezza
superiore a r + 1 bit è pari a p = 1-0,5r che per r = 32 vale p = 99,99998%
Il generatore G deve avere r + 1 bit cioè 33 bit.
2. Tre LAN dipartimentali sono collegate tra loro da una dorsale in fibra. La topologia di
ciascuna LAN e' a stella: le tre LAN usano rispettivamente le tecnologie ethernet 100BaseT,
10BaseT e 100BaseT. Ciascuna Lan finisce in uno switch ethernet con una uscita sulla
dorsale dove finiscono in un concentratore (hub) che interconnette le tre LAN, che a sua
volta esce nel router di frontiera dei tre dipartimenti. Quale caratteristica deve essere
richiesta per potere collegare le tre LAN in questo schema?
– che tutti e tre gli switch di ciascuna LAN abbiano una uscita sulla dorsale alla stessa
velocità delle porte del concentratore
3. Quattro reti IP 200.13.36.0/26, 200.13.36.64/26, 200.13.36.128/26 e 200.13.36.192/26 su
ethernet 100BaseT sono collegate tra loro via un router rispettivamente alle interfacce
200.13.36.1 di MAC address cc:cc:cc:cc:cc:c1, 200.13.36.65 di MAC address
cc:cc:cc:cc:cc:c2, 200.13.36.129 di MAC address cc:cc:cc:cc:cc:c3 e 200.13.36.193 di MAC
address cc:cc:cc:cc:cc:c4. L'host 1 di indirizzo IP 200.13.36.5 vuole spedire un datagramma
140
all'host 2 di indirizzo 200.13.36.150. Se il MAC address del host 1 è aa:aa:aa:aa:aa:aa e
quello dell'host 2 è bb:bb:bb:bb:bb:bb, a livello dello strato di link, quale indirizzo MAC di
destinazione deve impostare l'host sorgente sul frame affinchè il datagramma arrivi a 2?
– cc:cc:cc:cc:cc:c1
Va impostato l’indirizzo MAC del router di primo hop, sarà il router che lo instraderà sul
collegamento appropriato
4. Cosa succede quando due host A e B sono a distanza tale che il piu' piccolo frame ethernet
viene emesso completamente da A prima che il segnale di jam emesso da B a causa della
collisione arrivi in A?
– A è convinto di aver inviato il frame in modo corretto
5. Se una scheda di rete 10BaseT manda una sequenza infinita di 1 codificata con il
"Manchester encoding" quante transizioni al secondo si potranno osservare sulla LAN?
– 20E06
Nella codifica Manchester ci sono il doppio delle transizioni rispetto al numero di bit.
In questo caso la LAN è di tipo 10BaseT quindi ha un’ampiezza di banda di 10E06 bps
quindi il calcolo è presto fatto: 2*10E06 = 20E06
6. In un protocollo CSMA/CD per LAN Ethernet il segnale di jam è di 48 bit. Quanto tempo
impiega un host a trasmettere il segnale di jam su una LAN a 10 Mbps?
– 4,8 micro sec
48 bit
10 × 10 6
bit
s
= 4,8 × 10 6 s = 4,8μs
7. Consideriamo una LAN ethernet a 100Mbps. Per potere avere una efficienza dello 0,75
quale deve essere la massima distanza tra due nodi, assumendo che i frame siano quelli di
lunghezza minima e che il segnale viaggi a 250 milioni di metri al secondo?
– 96 m
E=
1
1 + 5a
a=
t propagazione
t trasmissione
L
d
t trasm =
R
v
1
1− E
1 1− E
1 1 − 0,75
⇒a= ⋅
⇒a= ⋅
= 0,066667
1 + 5a = ⇒ 5a =
5 E
5 0,75
E
E
d
t prop
L
L
d R
d
⇒ a = v ⇒ a = ⋅ ⇒ = a⋅ ⇒ d = a⋅ ⋅v =
a=
L
R
R
v L
v
t trasm
R
576 bit
m
= 0,66667 ⋅
⋅ 2,5 × 108
= 96 m
s
6 bit
100 × 10
s
t prop =
141
Architettura
8. Un messaggio di 1400 byte e' incapsulato in un segmento TCP con header di dimensioni
tipiche, a sua volta incapsulato in un datagramma IP con header di dimensioni tipiche ed
infine in un frame ethernet. Quale sarà la dimensione del frame ethernet?
– 1466 byte
20 byte TCP + 20 byte IP + 26 byte Ethernet
1400 + 20 + 20 + 206 = 1466 byte
9. Assumiamo che ci siano due host A e B attaccati alle opposte estremità di un segmento
ethernet alla distanza di 900 m. I due host devono inviare l'uno all'altro frame da 1.000 bit
ciascuno. Supponiamo che la velocità del segnale sia di 200 milioni di metri al secondo, che
l'ampiezza di banda sia di 10 Mbps e che ci siano quattro ripetitori tra i due host che
introducono un ritardo di 25 bit ciascuno sulla trasmissione. Entrambi gli host iniziano a
trasmettere a t=0. Dopo la collisione A estrae K=0 e B K=1. Dopo quanto tempo il frame di
B e' completamente consegnato ad A, assumendo che B inizi a trasmettere senza problemi
subito dopo che ha ricevuto il frame da A?
– 282 micro sec
Per il commento fare riferimento al commento multimediale fornito dal prof
http://corsionline.mlab.disco.unimib.it/lp/arch2006/lp5/domanda9/web/video.wvx
1. Il packet jitter è:
– La fluttuazione del ritardo di trasmissione
2. Uno schema FEC serve a:
– Correggere alcuni errori sfruttando l’informazione ridondante
3. Alice, Bob, Aldo, Giovanni e Giacomo stanno effettuando una conferenza audio usando SIP
con RTP/UDP. Come fa il client SIP di Alice a distinguere tra i messaggi ricevuti da Bob,
Aldo, Giovanni e Giacomo e ad associarli al rispettivo sender?
– Tramite RTCP
4. Alice, Bob, Aldo, Giovanni e Giacomo stanno effettuando una conferenza audio usando SIP
con RTP/UDP. Affinche' Alice possa riprodurre l'audio inviato/ricevuto su RTP da Bob,
Aldo, Giovanni e Giacomo quante socket UDP devono esserci? (oltre al socket necessario
per i messaggi SIP)
–2
SIP è un protocollo out of band come FTP
I pacchetti RTCP sono inviati ad una porta diversa da RTP quindi sono necessarie 2 socket.
5. Se il protocollo RTP viene usato per trasmettere un segnale telefonico campionato a 8KHz
con campioni di 8 bit, inviando un pacchetto ogni 20 ms, con uno header UDP di 8 byte,
header RTP di 12 byte e header IP di dimensioni standard quale deve essere la velocita'
minima di trasferimento della rete in modo che il segnale telefonico arrivi correttamente al
ricevitore? Assumente che gli strati sottostanti a quello di rete non introducano alcun
overhead di intestazione.
– 80 Kbps
142
8 KHz 1 byte Æ segnale 64 Kbit/s = 8 KB/s
64 Kbps * 20 msec = 160 byte di payload
20 byte IP + 8 byte UDP + 12 byte RTP = 200 byte ogni 20 msec
200 byte
KB
= 10
s
20 m sec
KB
8 ⋅ 10
= 80 Kbps
s
6. In uno schema fec viene usata la codifica PCM a 42kbps insieme ad una codifica a 10kbps a
bassa risoluzione con schema blocco n-esimo ad alta qualità + blocco (n-1)-esimo a bassa
qualità, con blocchi della durata di 20ms. Se il segnale audio è inviato via RTP/UDP su una
LAN ethernet, qual'è l'overhead introdotto con questa tecnica rispetto allo schema realizzato
con l’interleaving? Si approssimi il risultato al decimo di punto percentuale.
– 14,6%
Calcolo quant’è il payload:
(42 + 10) Kbps * 20 msec = 1040 bit = 130 byte
La dimensione del frame sarà:
130 byte + 12 byte RTP + 8 byte UDP + 20 byte IP + 26 byte Ethernet = 196 byte
42 Kbps * 20msec = 840 bit = 150 byte
il frame sarà 105 byte + 66 byte (le varie intestazioni) = 171 byte
L’overhead è quindi:
(196 − 171) byte ⋅ 100 = 25 byte ⋅ 100 = 14,6%
171 byte
171 byte
7. Una sessione multimediale usa RTP/UDP per trasmettere lo stream audio/video. La
larghezza di banda della sessione e' di 2Mbps. Se ci sono 2 sender e 50 receiver e la
dimensione media del pacchetto RTPC e' di 100byte, calcolare il periodo di trasmissione tra
due pacchetti RTCP sia per i sender che per i receiver.
– sender 64 msec – receiver 533 msec
R = 2 Mbps
LRTCP = 100 byte = 800 bit
NS = 2 (numero dei sender)
NR = 50 (numero dei receiver)
Il periodo di trasmissione per i sender è:
2
bit
0,25 ⋅ 0,05 ⋅ 2 × 10
s
6
NS
⋅ LRTCP
0,25 ⋅ 0,05 ⋅ R
⋅ 800 bit = 64 × 10 −3 s
143
Architettura
Il periodo di trasmissione dei receiver è:
50
bit
0,25 ⋅ 0,05 ⋅ 2 × 10 6
s
NR
⋅ LRTCP
0,25 ⋅ 0,05 ⋅ R
⋅ 800 bit = 533 × 10 −3 s
8. Una sessione multimediale usa RTP/UDP per trasmettere lo stream audio/video. La
larghezza di banda della sessione è di 1Mbps. Se l’intervallo di trasmissione tra due
pacchetti RTCP è di 128 ms per i sender e di 960 ms per i receiver, calcolare il numero di
sender e di receiver, se la dimensione media del pacchetto RTPC è di 100byte.
– 2 sender e 45 receiver
sender
Δt RTCP
=
NS
⋅ LRTCP
0,25 ⋅ 0,05 ⋅ R
N S = 0,25 ⋅ 0,05 ⋅
receiver
Δt RTCP
=
R
LRTCP
sender
⋅ Δt RTCP
bit
s ⋅ 128 × 10 −3 s = 2
= 0,25 ⋅ 0,05 ⋅
2
8 × 10 bit
1 × 10 6
NR
⋅ LRTCP
0,25 ⋅ 0,05 ⋅ R
N R = 0,25 ⋅ 0,05 ⋅
R
LRTCP
receiver
⋅ Δt RTCP
bit
s ⋅ 960 × 10 −3 s = 45
= 0,75 ⋅ 0,05 ⋅
2
8 × 10 bit
1 × 10 6
9. Volete ascoltare musica da una “radio” su Internet che trasmette musica codificata MP3 a
96kbps. Se i dati vengono raccolti in blocchi ogni 10ms e quindi spediti con RTP/UDP, di
quanta larghezza di banda avete bisogno, se siete collegati ad una LAN ethernet? Assumete i
valori tipici di dimensione delle intestazioni dei vari strati.
– 148,8 Kbps
96 kbps * 10 msec = 960 bit = 120 byte di payload
La dimensione del frame è: 120 + 12 + 8 + 20 + 26 = 186 byte
8 ⋅ 186 bit
8 ⋅ 186 bit
La banda è
=
= 148,8 Kbps
10 m sec 10 × 10 −3 s
10. Una implementazione di Internet realizza uno schema per fornire QoS, permettendo di
discriminare i flussi secondo i 4 principi visti a lezione. In particolare una applicazione ftp
contende l’uso di un link con ampiezza di banda R=1,5 Mbps ad una applicazione
multimediale real time. Se i flussi relativi alle due applicazioni hanno assegnata
rispettivamente 1/3 e 2/3 della banda del link e l’applicazione in tempo reale trasmette per il
90% totale del tempo, calcolare il tempo necessario per trasferire via ftp un file di 1Gbyte.
(tempo risolto al minuto primo)
– 3 ore 42 minuti
144
1
+
= 0,4 ⋅ R = 0,6 Mbps
01
,2
1 ⋅3
R
0,9 ⋅ R
33
1
424
lo stream non
tempo trasmissione sta trasmettendo
stream
bit
8 × 10 9
s = 8 × 10 4 s = 4 × 10 4 s = 222,2 min = 3h.42 min
bit 6
3
6 × 10 5
s
R FTP =
145

Architetture di un elaboratore e reti

Transcript

Documenti analoghi

Esercizio Multiplazione Inversa SOLUZIONE:

Sicurezza

Esercizio Circuitmaker 2005-2006 Si progetti un comparatore

informatica2 - Università di Verona

Gioca Jouer: centro di ricreazione e divertimento per bambini

Scheda tecnica

Broadband Sigma-Delta A/D Converters - ETH E

In Taberna Quando Sumus

¡CD ¡..

Scarica pdf