Architetture di un elaboratore e reti
Transcript
Architetture di un elaboratore e reti
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 ultima modifica: 27/11/2006 ultima modifica: 29/11/2006 ultima modifica: 23/01/2007 (Contiene 0 errore/i) (Contiene 1 errore/i) (Contiene 0 errore/i) (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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria • • • 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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. Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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. Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria [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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 ) Formula per tempo totale con file html base e 10 t = 2 RTT + TT + 10(RTT + TTI ) oggetti Connessione persistente con pipelining Formula generale t = 2 RTT + TT + RTT + ( Nfile ⋅ TTI ) Formula per tempo totale con file html base e 10 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Esercitazione del 24 / 1 / 2007 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria ( ) 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Esercitazione del 31 / 1 / 2007 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria È 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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 Quaderno virtuale di teoria 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