Semplici metodi di accodamento "senza classi"
Come già detto con i metodi di accodamento non cambiamo il modo con cui i dati ci vengono mandati. Gli accodamenti "senza classi" sono quelli che a fronte di una grande quantità di dati in arrivo, alcuni di questi vengono o fatti passare o trattenuti (ritardati) oppure cestinati.
Questi metodi possono essere usati per modellare il traffico di una intera interfaccia, senza alcuna suddivisione.
Il più usato dei metodi senza classi è il pfifo_fast qdisc , che viene usato come default e non è altro che una classica coda First In First Out.
Tutti i vari metodi avanzati derivano da quest'ultimo, e ne rappresentano solo una variante.
pfifo_fast
Questa coda è, come dice il nome, del tipo First In-First Out, che significa che nessun pacchetto riceve un trattamento speciale. Questa coda ha 3 così dette "bande", e all'interno di ognuna di esse viene applicata la logica FIFO.
La "colonna" zero ha la massima priorità e fino a che non si svuota le altre rimangono in attesa, allo stesso modo la colonna numero 2 non potrà svuotarsi fino a che ci sono pacchetti nella colonna numero 1.
Parametri ed uso
Per configurare questo tipo di accodamento ci serviamo di 2 parametri.
Il primo parametro è priomap che determina la priorità dei pacchetti.Il nucleo del sistema operativo legge il TOS (Type of Service) nel campo d'intestazione di un pacchetto IP, ed è in base al valore di questo campo che i pacchetti sono divisi in ranghi o bande.
0 1 2 3 4 5 6 7
+-----+-----+-----+-----+-----+-----+-----+-----+
| | | |
| PRECEDENCE | TOS | MBZ |
| | | |
+-----+-----+-----+-----+-----+-----+-----+-----+
Quattro degli otto bit TOS campi sono definiti come indicato nella tabella sotto:
Binario Decimale Significato
-----------------------------------------
1000 8 Minimizza il ritardo (md)
0100 4 Massimizza il throughput (mt)
0010 2 Massimizza affidabilità (mr)
0001 1 Minimizza il costo (mmc)
0000 0 Normale
Non bisogna confondere questo tipo di accodamento con uno che usa le classi, perché sebbene abbiano un comportamento simile, il pfifo_fast è senza classi e non potrete aggiungere, per esempio, un altra coda qdisc col comando tc.
Col comando "tcpdump -vv" verrà mostrato il valore dell'intero campo TOS di ogni pacchetto, non solo dei primi 4 bit.
TOS Bits Significato Linux Priority Banda
------------------------------------------------------------
0x0 0 Normale 0 Migliore sforzo 1
0x2 1 Minimizza Costo 1 Riempitore 2
0x4 2 Massimizza Affidabilità 0 Migliore sforzo 1
0x6 3 mmc+mr 0 Migliore sforzo 1
0x8 4 Massimizza Throughput 2 Rinfusa 2
0xa 5 mmc+mt 2 Rinfusa 2
0xc 6 mr+mt 2 Rinfusa 2
0xe 7 mmc+mr+mt 2 Rinfusa 2
0x10 8 Minimize Delay 6 Interattivo 0
0x12 9 mmc+md 6 Interattivo 0
0x14 10 mr+md 6 Interattivo 0
0x16 11 mmc+mr+md 6 Interactive 0
0x18 12 mt+md 4 Int. Rinfusa 1
0x1a 13 mmc+mt+md 4 Int. Rinfusa 1
0x1c 14 mr+mt+md 4 Int. Rinfusa 1
0x1e 15 mmc+mr+mt+md 4 Int. Rinfusa 1
Le prime 2 colonne contengono il possibile valore in formato sia esadecimale che decimale e dato che si tratta di un numero a 4 bit il suo valore varia da 0 a 15. Per esempio se il campo TOS contenesse il numero 15 vorrebbe dire che tutti i 4 bit sarebbero impostati ad 1 e di conseguenza il pacchetto richiederebbe la combinazione di tutte e quattro le caratteristiche descritte nella tabella precedente: Minimo Costo Monetario, Massima Affidabilità, Massimo Throughput e Minimo Ritardo.
La quarta colonna rappresenta come il kernel Linux interpreta i bits del TOS, mostrando con che priorità vengono mappati.
L'ultima colonna mostra il risultato della priomap di default. Da linea di comando una priomap apparirebbe così:
1, 2, 2, 2, 1, 2, 0, 0 , 1, 1, 1, 1, 1, 1, 1, 1
Questo significa che i pacchetti che il kernel interpreta come priorità 4, per esempio, verranno inseriti nella banda numero 1 del nostro accodamento FIFO_fast e priorità anche maggiori di 7 che non risultano dal mappagio TOS possono essere usate ai fini dell'accodamento.
La seguente tabella estratta dal RFC 1349 ci mostra come varie applicazioni impostano il TOS dei loro pacchetti:
TELNET 1000 (minimizza ritardo)
FTP
Control 1000 (minimizza ritardo)
Data 0100 (massimizza throughput)
TFTP 1000 (minimizza ritardo)
SMTP
Command phase 1000 (minimizza ritardo)
DATA phase 0100 (massimizza throughput)
Domain Name Service
UDP Query 1000 (minimizza ritardo)
TCP Query 0000
Zone Transfer 0100 (massimizza throughput)
NNTP 0001 (minimizza costo monetario)
ICMP
Errors 0000
Requests 0000
Responses 0000
Il secondo parametro è txqueuelen con il quale impostiamo la lunghezza della coda ed è possibile impostarlo dalla configurazione delle interfacce, tramite il comando ifconfig e ip.
Per impostare la lunghezza della coda a 10 basta eseguire il comando:
ifconfig eth0 txqueuelen 10
Non è possibile mostrare il valore di questo parametro con il comando tc.
Token Bucket Filter
Il Token Bucket Filter (TBF) è un semplice metodo di accodamento che fa passare i pacchetti in arrivo che non superano una velocità di soglia preimpostata e con la possibilità di consentire dei piccoli eccessi rispetto a questa soglia.
Il TBF è molto preciso e non necessita di una gran capacità di calcolo, e dovrebbe essere essere preso in considerazione come prima metodo per rallentare semplicemente una interfaccia.
Questa struttura di coda è immaginabile come una secchio con un buco sul fondo per cui il flusso in uscita tende ad essere costante (a meno che il secchio non sia vuoto). Quando viene riempito troppo velocemente si riempi e l'acqua in eccesso cade ai bordi e non è più recuperabile. Allo stesso modo possiamo definire la dimensione massima della coda e il suo rate di uscita .
La sua implementazione consiste in un buffer (bucket), costantemente riempito da alcuni pezzi virtuali di informazione chiamati tokens, a una specifica velocità (token rate). Il parametro più importante del "secchio" è la sua grandezza, che è data dal numero di tokens che può immagazzinare. I tokens sono come degli slot vuoti che fluiscono all'interno del buffer e prendendosi carico dei pacchetti li fanno transitare all'interno della coda.
In questo tipo di accodamento abbiamo due tipi di flussi:
- Il flusso dei dati in arrivo
- Il flusso di token che liberi che si propongono
a seconda della velocità relativa di questi 2 flussi ci possiamo trovare in alcune situazioni:
- I dati che arrivano alla coda hanno la stessa velocità dei token. In questo caso tutti i pacchetti di dati verranno allocati nei rispettivi slot(token) e passeranno attraverso la coda (bucket) senza ritardi.
- I dati che arrivano al TBF hanno una velocità inferiore di quella con cui si liberano i token. anche in questo caso non ci saranno ritardi.
- I dati che arrivano nella coda hanno una velocità maggiore dei token. questo significa che il contenitore sarà ben presto a corto di token liberi, e ci troveremo in una situazione di "fuori limite" e i pacchetti in arrivo verranno scartati.
L'ultimo scenario è molto importante, perché consente di limitare il flusso di dati imponendo una banda massima come filtro.
La capacità del contenitore, misurata in token, non è del tutto fissa, ma consente alcune variazioni per eccesso. L'accumulazione dei token liberi potrebbe portare la capacita del contenitore un po oltre la sua soglia, e per un breve periodo di tempo si potrebbe avere una velocità in uscita un po superiore (bursts), ma in situazioni di sovraccarico i pacchetti verranno in un primo momento ritardati e poi infine scartati.
Notare che nella attuale implementazione dei token essi sono misurati in bytes non in pacchetti
Uso:
... tbf limit BYTES burst BYTES[/BYTES] rate KBPS [ mtu
BYTES[/BYTES] ][ peakrate KBPS ] [ latency TIME ]
- burst/buffer/maxburst: indica la dimensione del secchio in bytes. Limita il numero massimo in bytes occupabile dai tokens in un determinato istante. In teoria dovrebbe essere proporzionato rispetto alla velocità che si vuole trasmettere.
- limit or latency: con la latenza indico il tempo massimo che un pacchetto può restare all'interno della coda, mentre con limit indico il numero di byte che possono restare in attesa di un token disponibile.
- rate : indica quanti tokens al secondo ho a disposizione, in pratica è la velocità massima di trasmissione.
- mpu:pacchetti al di sotto di questa dimensione non vengono accodati. La Minimum Packet Unit determina la taglia dei token per i pacchetti.
- peakrate: Se un token è disponibile e dei pacchetti arrivano, sono spediti immediatamente. Questa potrebbe non essere la tua volontà specie se hai un grosso secchio. Il peakrate indica al massimo quanto rapidamente vuoi che si svuoti il secchio.
- mtu/minburst Se avessimo un 1mbit/s di peakrate ed una velocità(rate) molto maggiore questo non sarebbe molto conveniente. Un peakrate più grande è possibile mandando più pacchetti per timertick, è questo parametro mtu/minburst ci da la grandezza di questa cache a causa delle restrizioni sul peakrate.
Esempio di TBF
Una configurazione molto utile potrebbe essere questa:
# tc qdisc add dev ppp0 root tbf rate 220kbit latency 50ms burst 1540
perché questo tipo di accodamento potrebbe farci comodo? Se avessimo un dispositivo che ci connette ad internet con una "coda" molto capiente, quale potrebbe essere un router con un modem DSL, e vogliamo comunicare con Skype o qualche altro sistema di comunicazione vocale, il nostro upload distruggerebbe l'interatività. Questo perché la coda capiente del router verrebbe riempita dai dati in upload e i dati della comunicazione vocale verrebbero accodati e probabilmente spediti in ritardo, ma questo in una comunicazione realtime è inaccettabile.
Quindi quello che faccio io è di limitare i dati in uscita dal mio pc così da non dover usare l'accodamento nel router. Nell'esempio è stata impostata una velocità di upload di 220kbit, nel caso vogliate usare questo comando aggiornate il numero a valore di upload della vostra connessione ad internet meno una certa percentuale. Se avete un modem molto veloce potete incrementare un po il valore di 'burst'.
Stochastic Fairness Queueing
Stochastic Fairness Queueing (SFQ) , tradotto sarebbe metodo di accodamento nel giusto ordine, è una semplice applicazione di metodi per la gestione del traffico della famiglia dei metodi di parità del controllo.
È meno accurato rispetto agli altri, ma è molto più veloce (meno calcoli), con la caratteristica dello stesso trattamento per tutti i pacchetti.
La principale caratteristica del metodo SFQ è che tratta allo stesso modo indistintamente i dati con protocollo TCP e UDP della sessione corso.
Individua quindi ogni sessione TCP o UDP e divide stocasticamente il traffico in flussi, e ad ogni flusso viene assegnata una qdisc FIFO (coda) alla quale a turno viene data la possibilità di trasmettere.
L'algoritmo Round Robin, si occupa di inviate a turno da ogni coda creata un certa quantità di dati (quantum), e questo si traduce in una parità di condotta, ed esclude la possibilità che un flusso sia preferito ad un altro.
Questo comportamento "giusto" fa in modo che nessuna singola "conversazione" prevalga sulle altre. L'SFQ è chiamato "Stocastico" perché non crea realmente una coda per ogni sessione, ma ha un algoritmo che smista il traffico su un numero limitato di code usando un algoritmo di rimescolamento casuale (hash).
A causa di quest'ultimo, sessioni multiple potrebbero finire nella stessa coda, per cui queste sessioni avrebbero la metà delle possibilità di trasmettere, e quindi metà della velocità rispetto alle altre, che hanno una coda per conto loro.
Per prevenire questo l'SFQ cambia l'algoritmo di hash abbastanza spesso così che due sessioni verrebbero dirette nella stessa coda (collisione) solo per un po di tempo.
Bisogna notare che l'SFQ è utile solo se l'interfaccia d'uscita a cui viene applicato è veramente satura, altrimenti non ci sarebbe alcun vantaggio dato che non si noterebbero gli effetti. Quindi il consiglio è quello di utilizzarlo insieme ad altri metodi di accodamento, in modo da sfruttare i vantaggi di entrambi i metodi.
Parametri ed uso
Il metodo SFQ è facilmente configurabile:
Uso: ... sfq [ perturb SECS ] [ quantum BYTES ] [ limit ]
perturb: parametro per l'algoritmo di confusione (tempo di miscelazione). Stabilisce dopo quanti secondi vine modificato l'algoritmo. Se il parametro non è impostato l'algoritmo non verrà mai cambiato e questo è sconsigliato. Un valore accettabile è 10 secondi.
quantum: numero di bytes trasmittibili prima di cedere la mano. Di default è il valore del' MTU (la grandezza massima per un pacchetto), non bisogna mai impostare questo valore in maniera tale che sia inferiore all'MTU.
limit : numero totale di pacchetti che possono essere accodati dall' SFQ (dopo il quale verranno scartati).
Esempio di configurazione
Per impostare l'SFQ sulla interfaccia del nostro pc collegata al modem o al router lanciamo questi comandi:
# tc qdisc add dev ppp0 root sfq perturb 10
# tc -s -d qdisc ls
qdisc sfq 800c: dev ppp0 quantum 1514b limit 128p flows 128/1024 perturb 10sec
Sent 4812 bytes 62 pkts (dropped 0, overlimits 0)
Il secondo comando mostra i parametri del metoto che abbiamo impostato col primo comando.
Il numero 800c: è l'identificativo automaticamente assegnato alla qdisc, il parametro limit è impostato a 128 che è la grandezza della coda (totale). Ci sono poi 1024 hashbuckets (code FIFO) disponibili, di cui se ne possono usare 128 alla volta, dato che questa è la dimensione massima della coda. Ogni 10 secondi l'algoritmo viene riconfigurato.
RED
Una coda Red (random Early Detection) può essere vista come una variante di quella FIFO in quanto in uscita i pacchetti sono spediti allo stesso modo mentre ciò che varia è il meccanismo di accodamento. Innanzi tutto bisogna definire due soglie una minima e una massima. Per capire come lavorano aiutiamoci con un grafico:
Quando la coda ha una lunghezza maggiore o uguale della soglia massima qualunque pacchetto che arriva viene scartato, mentre quando ci si trova tra le due soglie inizia uno scarto casuale dei pacchetti in arrivo con una probabilità crescente tanto più la coda si riempie.
Uso:
... red limit BYTES min BYTES max BYTES avpkt BYTES burst PACKETS probability PROBABILITY bandwidth KBPS [ ecn ]
In pratica questo tipo di algoritmo si usa solitamente per grossi volumi di traffico,ad esempio collegamenti a 100Mbps, con i quali bisogna usare delle code molto capienti, questo perché il traffico è tanto e dobbiamo garantire che le trasmissioni vadano a buon fine, quindi diminuire le ritrasmissioni. A questo scopo è stato introdotto quelsto algoritmo che evita la congestione del traffico, controllando lo stato della coda utilizzando le due soglie. In questo modo le connessioni che occupano più banda hano più probabilità di essere "tagliate" evitando così la congestione globale.
Nella realtà questo algoritmo viene assocciato all'ECN (Explicit Congestion Notification) per notificare agli host situazioni di congestione della rete marcando i pacchetti in modo opportuno. Gli host che supportano l'ECN saranno saranno in grado di auto limitarsi riducendo al congestioen della rete (RFC 3168).
Per approfondimenti leggere questo articolo.
