Qdisc Classless

Autor Original do texto:

Martin A. Brown
martin@linux-ip.net
http://linux-ip.net

6. Disciplinas de Enfileiramento Classless (qdisc’s)

Cada uma dessas disciplinas de enfileiramento pode ser usada como a qdisc primária sobre uma interface, ou pode ser usada dentro de uma classe folha de uma qdisc classful. Esses são os escalonadores fundamentais usados sob o Linux. Observe que o escalonador padrão é o pfifo_fast.

6.1 FIFO, First-In First-Out (pfifo e bfifo)

Primeiro a Entrar, Primeiro a Sair.

Obs.:
Essa não é a qdisc padrão sobre as interfaces Linux. Esteja certo de ver a Seção 6.2, “pfifo_fast, a qdisc padrão Linux” para detalhes completos sobre a qdisc (pfifo_fast) padrão.

O algoritmo FIFO forma a base para a qdisc padrão sobre todas as interfaces de rede Linux (pfifo_fast). Ela não executa nenhum shaping ou re-arrumação de pacotes. Ela simplesmente transmite pacotes tão logo possa depois que os recebe e enfileira. Essa é também a qdisc usada dentro de todas as classes criadas mais recentemente até que uma outra qdisc ou uma classe substitua a fila FIFO.

Uma qdisc FIFO real precisa, contudo, ter um limite de tamanho (um tamanho de buffer) para evitar que ela estoure no caso que ela fique incapaz de des-enfileirar pacotes tão rapidamente quanto ela os recebe. O Linux implementa duas qdisc’s FIFO, uma baseada em bytes, e a outra em pacotes. Independentemente do tipo de qdsic FIFO usada, o tamanho da fila é definida pelo parâmetro limit. Para uma fila pfifo a unidade é entendida ser pacotes e para uma bfifo a unidade é entendida ser bytes.

Exemplo 6. Especificando um limit para uma fila FIFO pacote ou byte


[root@leander]# cat bfifo.tcc
/*
 * criando uma fila FIFO sobre eth0 com tamanho de fila 10kbyte
 *
 */

dev eth0 {
    egress {
        fifo (limit 10kB );
    }
}
[root@leander]# tcc < bfifo.tcc
# ================================ Device eth0 ================================

tc qdisc add dev eth0 handle 1:0 root dsmark indices 1 default_index 0
tc qdisc add dev eth0 handle 2:0 parent 1:0 bfifo limit 10240
[root@leander]# cat pfifo.tcc
/*
 * criando uma fila FIFO sobre eth0 com tamanho de 30 pacotes
 *
 */

dev eth0 {
    egress {
        fifo (limit 30p );
    }
}
[root@leander]# tcc < pfifo.tcc
# ================================ Device eth0 ================================

tc qdisc add dev eth0 handle 1:0 root dsmark indices 1 default_index 0
tc qdisc add dev eth0 handle 2:0 parent 1:0 pfifo limit 30

6.2 pfifo_fast, a qdisc padrão Linux

A qdisc pfifo_fast é a qdisc padrão para todas as interfaces sob o Linux. Baseada em uma qdisc FIFO convencional, essa qdisc também fornece alguma priorização. Ela fornece três diferentes bandas (FIFO’s individuais) para separação de tráfego. O tráfego com prioridade mais elevada (fluxos interativos) são colocados na banda 0 e são sempre servidos primeiro. De modo similar, a banda 1 é sempre esvaziada de pacotes pendentes antes que a banda 2 seja des-enfileirada.

Não existe nada configurável ao usuário final a respeito da qdisc pfifo_fast. Para detalhes exatos sobre o priomap e o uso dos bits ToS, veja o HOWTO do LARTC na seção pfifo-fast.

6.3 SFQ, Stochastic Fair Queuing

A qdsic SFQ tenta distribuir de forma justa a oportunidade de transmitir dados na rede entre um número arbitrário de fluxos. Ela consegue isso usando uma função hash para separar a tráfego em FIFO’s (mantidas internamente) separadas que são des-enfileiradas em um modo cíclico (round-robin). Como existe possibilidade para manifestar imparcialidade na escolha da função hash, essa função é alterada periodicamente. A perturbação (o parâmetro perturb) é ajustada periodicamente.

Exemplo 7. Criando uma SFQ


[root@leander]# cat sfq.tcc
/*
 * criando uma qdisc SFQ sobre a eth0 com uma perturbação de 10 segundo
 *
 */
dev eth0 {
    egress {
        sfq( perturb 10s );
    }
}
[root@leander]# tcc < sfq.tcc
# ================================ Device eth0 ================================
tc qdisc add dev eth0 handle 1:0 root dsmark indices 1 default_index 0
tc qdisc add dev eth0 handle 2:0 parent 1:0 sfq perturb 10

Infelizmente, alguns softwares espertos (por exemplo, Kazaa e eMule entre outros) destroem o benefício dessa tentativa de enfileiramento justo abrindo tantas sessões TCP (fluxos) quanto possam ser suportadas. Em muitas redes, com usuários bem comportados, o SFQ pode distribuir adequadamente os recursos de rede aos fluxos que concorrem, mas outras medidas podem ser exigidas quando aplicações agressivas tenham invadido a rede.

Veja também a Seção 6.4, “ESFQ, Extended Stochastic Fair Queuing” para uma qdisc SFQ melhorada com mais parâmetros expostos para o usuário manipular.

6.4 ESFQ, Stochastic Fair Queuing Extendido

Conceitualmente, essa qdisc não é diferente da SFQ embora ela permita ao usuário controlar mais parâmetros que sua parenta mais simples. Essa qdisc foi concebida para superar a desvantagem da SFQ identificada acima. Permitindo que o usuário controle qual algoritmo que implementa a função hash seja usado para distribuir à largura de banda de acesso, é possível ao usuário alcançar uma distribuição de largura de banda real mais regular.

Exemplo 8. Uso do ESFQ


Usage: ... esfq [ perturb SECS ] [ quantum BYTES ] [ depth FLOWS ]
        [ divisor HASHBITS ] [ limit PKTS ] [ hash HASHTYPE]
Where:
HASHTYPE := { classic | src | dst }

CORRIJAM-ME; carece de experiência prática e/ou validação aqui.

6.5 GRED, Random Early Drop Genérico

CORRIJAM-ME; Eu nunca usei esse. Carece de experiência prática ou validação.

A Teoria declara que um algoritmo RED é útil em um backbone ou rede núcleo, porém não é tão útil próximo ao usuário final. Veja a seção sobre fluxos pra ver uma discussão geral da sede do TCP.

6.6 TBF, Token Bucket Filter

Essa qdisc é construída sobre tokens e buckets. Ela simplesmente atrasa o tráfego transmitido sobre uma interface. Para limitar a velocidade daqueles pacotes que serão des-enfileirados de uma interface particular, a qdisc TBF é a solução perfeita. Ela simplesmente deixa lento o tráfego transmitido à taxa especificada.

Pacotes somente são transmitidos se existir tokens disponíveis suficientemente. Caso contrário, os pacotes serão atrasados. Atrasando pacotes dessa forma introduzirá uma latência artificial no tempo de viagem do pacote.

Exemplo 9. Criando uma TBF 256kbit/s


[root@leander]# cat tbf.tcc
/*
 * criando uma qdisc TBF 256kbit/s sobre a eth0
 *
 */

dev eth0 {
    egress {
        tbf( rate 256 kbps, burst 20 kB, limit 20 kB, mtu 1514 B );
    }
}
[root@leander]# tcc < tbf.tcc
# ================================ Device eth0 ================================

tc qdisc add dev eth0 handle 1:0 root dsmark indices 1 default_index 0
tc qdisc add dev eth0 handle 2:0 parent 1:0 tbf burst 20480 limit 20480 mtu 1514 rate 32000bps