Esercizio - Pacchetti di C verso E e G con traffico concorrente

Testo. Rete a commutazione di pacchetto a datagramma (store-and-forward), code indipendenti per ogni interfaccia di uscita. A $t=0$: la coda di uscita dell'host A ha due pacchetti diretti a D, D; quella dell'host B un pacchetto diretto a F; quella dell'host C due pacchetti diretti rispettivamente a E e G. Tutti i pacchetti sono lunghi $L=1500$ byte e le trasmissioni partono a $t=0$ in tutti gli host. Calcolare l'istante di arrivo dei soli due pacchetti di C.

Topologia: A, B e C sono collegati al router R1; R1 – R2 – R3 sono in catena; D ed E sono collegati a R2; F e G sono collegati a R3.

Cammini: A→D: $C_1,C_2,C_7$; B→F: $C_5,C_2,C_3,C_4$; C→E: $C_6,C_2,C_8$; C→G: $C_6,C_2,C_3,C_9$. Il traffico di A e B serve solo a occupare $C_2$.

Teoria usata: Commutazione di circuito e di pacchettoUn nodo di commutazione (switch) può collegare ingresso e uscita in tre modi. Commutazione di circuito: si stabilisce prima un collegamento fisico dedicato (rete telefonica), tempo di consegna $T=3Nt_p+Nt_s+M/R$. Commutazione di pacchetto a datagramma: il messaggio è diviso in $K$ pacchetti con intestazione, ognuno è instradato indipendentemente con store-and-forward, $T=Nt_p+(N+K-1)\frac{M/K+H}{R}$, con $K_{ott}=\sqrt{(N-1)M/H}$. A circuito virtuale: tre fasi (setup, dati, chiusura), connessione logica dedicata ma senza risorse dedicate, identificatore locale che cambia a ogni salto.Commutazione di circuito e di pacchetto →, Analisi delle prestazioni di reteLe prestazioni di una rete si misurano con tre famiglie di metriche: traffico (bitrate $R_0$ massimo del collegamento, throughput $S\le R_0$ dati consegnati con successo, goodput al livello applicazione), ritardo (end-to-end $d_{tot}=d_{proc}+d_{queue}+d_{trans}+d_{prop}$ con $d_{trans}=L/R$ e $d_{prop}=d/v$; jitter; RTT) e capacità del tubo (BDP $=R\cdot$ ritardo, bit che riempiono il collegamento), più l'affidabilità (PER, PDR, PLR). Il throughput di un percorso è quello del collegamento collo di bottiglia, $\min$ dei bitrate, ricordando che i collegamenti condivisi dividono la capacità.Analisi delle prestazioni di rete →.

Regola di calcolo

Per ogni collegamento: $t_{inizio}=\max(t_{pronto},t_{libero})$, $t_{fine}=t_{inizio}+L/C$, il pacchetto è pronto al nodo successivo a $t_{fine}+\tau$. Le code sono FIFO, nell'ordine in cui i pacchetti sono arrivati per intero al router. Con $L=1500\cdot8=12000$ bit (e $T=L/C$, per esempio $12\,000/(6\cdot10^{6})=2\cdot10^{-3}$ s $=2$ ms su $C_2$):

Passo 1: dagli host a R1

Gli host trasmettono i pacchetti uno dietro l'altro; il tempo di arrivo in R1 è $t_{fine}+\tau$:

(ms; tabella già ordinata per arrivo.) Nessun pacchetto aspetta in questo tratto: ogni host usa un collegamento suo.

Passo 2: la coda su $C_2$ (R1 → R2), il collo di bottiglia

Tutti e cinque i pacchetti devono passare da $C_2$ ($6$ Mbit/s, $2$ ms ciascuno). R1 li serve nell'ordine di arrivo:

Il pacchetto C→G aspetta $9{,}3-2{,}1=7{,}2$ ms in coda: è l'ultimo ad arrivare e deve cedere il passo agli altri quattro. Il diagramma riassume l'occupazione di $C_2$ e dei collegamenti successivi usati dai pacchetti di C (il colore 2 sono i pacchetti di A, il colore 3 quello di B):

Passo 3: il pacchetto verso E

In R2 il pacchetto parte su $C_8$ ($4$ Mbit/s, $3$ ms). L'interfaccia $C_8$ è libera (nessun altro la usa): inizio $7{,}3$, fine $10{,}3$, arrivo a E a $10{,}3+1{,}5=\mathbf{11{,}8}$ ms.

Passo 4: il pacchetto verso G

Pronto in R2 a $15{,}3$ ms, esce su $C_3$ ($12$ Mbit/s). Controllo della coda su $C_3$: l'unico altro pacchetto che la usa è B→F, arrivato in R2 a $11{,}3$ e già uscito a $12{,}3$; quindi $C_3$ è libera a $15{,}3$ e non c'è attesa. $C_3$: $15{,}3\to16{,}3$, pronto in R3 a $16{,}3+4=20{,}3$. $C_9$: $20{,}3\to20{,}8$ (tempo $0{,}5$ ms), arrivo a G a $20{,}8+6=\mathbf{26{,}8}$ ms.

(Per completezza: A1 arriva a D a $13{,}8$ ms, A2 a $17{,}8$ ms, B→F a $18{,}8$ ms.)

Confronto con la soluzione ufficiale

Ufficiale: $11{,}8$ ms (verso E) e $26{,}8$ ms (verso G). Coincide. Il testo ufficiale parla di "first packet towards E" e "first packet towards G": sono i due pacchetti di C, uno per destinazione.

Errori comuni

• Servire $C_2$ nell'ordine di partenza dagli host invece che di arrivo in R1: C→E e C→G non arrivano insieme (distano $0{,}8$ ms).
• Dimenticare che il secondo pacchetto di C parte solo quando il primo è uscito dall'host (a $0{,}8$ ms, non a $0$).
• Contare in coda su $C_3$ anche i pacchetti di A (vanno su $C_7$, non su $C_3$).
• Dimenticare di sommare la propagazione di ogni salto, anche dell'ultimo.

(Verificato con Python: simulatore a eventi FIFO; C→E $11{,}8$ ms, C→G $26{,}8$ ms, A1 $13{,}8$, A2 $17{,}8$, B→F $18{,}8$.)