Camada de Transporte

(cont.)
• Serviços da camada de • Transporte orientado para
transporte conexão: TCP
• Multiplexação e o estrutura de segmento
demultiplexação o transferência confiável de
dados
• Transporte não o controle de fluxo
orientado para conexão: o gerenciamento da conexão
UDP • Princípios de controle de
• Princípios da congestionamento
transferência confiável • Congestionamento no TCP
de dados

slide 3
 Desempenho do rdt3.0
• rdt3.0 funciona, mas com desempenho ruim
• ex.: enlace 1 Gbps, 15 ms atraso propriedade, pacote
8000 bits:

• U remet: utilização – fração do tempo remet. ocupado enviando

• Pct. 1 KB cada 30 ms -> 33 kB/s vazão em enlace de 1 Gbps

• protocolo de rede limita uso de recursos físicos!

slide 39
 rdt3.0: operação pare e
espere

slide 40
 Protocolos com paralelismo
paralelismo: remetente permite múltiplos pacotes “no
ar”, ainda a serem reconhecidos
• intervalo de números de sequência deve ser aumentado
• buffering no remetente e/ou destinatário

• duas formas genéricas de protocolo com paralelismo:

Go-Back-N, repetição seletiva
slide 41
 Paralelismo: utilização
aumentada

Aumento de utilização
por fator de 3!

slide 42
Protocolos com paralelismo
Go-back-N: visão geral Repetição seletiva: visão geral
• remetente: até N pacotes não • remetente: até pacotes não
reconhecidos na pipeline reconhecidos na pipeline
• destinatário: só envia ACKs • destinatário: reconhece (ACK)
cumulativos pacotes individuais
o não envia pct ACK se houver • remetente: mantém temporizador
uma lacuna para cada pct sem ACK
• remetente: tem temporizador o se o temporizador expirar:
para pct sem ACK mais retransmite apenas o pacote sem
antigo ACK
o se o temporizador expirar:
retransmite todos os pacotes
sem ACK

slide 43
 Go-Back-N
remetente:
• # seq. de k bits no cabeçalho do pacote
• “janela” de até N pcts consecutivos sem ACK permitidos

• ACK(n): ACK de todos pcts até inclusive # seq. n – “ACK cumulativo”

o pode receber ACKs duplicados (ver destinatário)
• temporizador para cada pacote no ar
• timeout(n): retransmite pct n e todos pcts com # seq. mais alto na
janela

slide 44
 GBN: FSM estendido no
remetente
rdt_send(dados)
if (nextseqnum < base+N) {
pctenv[nextseqnum] = make_pkt(nextseqnum,dados,chksum)
udt_send(pctenv[nextseqnum])
if (base = = nextseqnum)
start_timer
nextseqnum++
}
else
^ refuse_data(dados)
base = 1
nextseqnum = 1
timeout
start_timer
Espera udt_send(pctenv[base])
rdt_rcv(pctrec) udt_send(pctenv[base+1])
&& corrupt(pctrec) …
udt_send(pctenv[nextseqnum-1])
^ rdt_rcv(pctrec) &&
notcorrupt(pctrec)
base = getacknum(pctrec)+1
If (base = = nextseqnum)
stop_timer
else
start_timer
slide 45
 GBN: FSM estendido no
destinatário
default
udt_send(pctenv) rdt_rcv(pctrec)
&& notcurrupt(pctrec)
&& hasseqnum(pctrec,expectedseqnum)
expectedseqnum = 1 Espera extract(pctrec,dados)
pctenv = deliver_data(dados)
make_pkt(expectedseqnum,ACK,chksum) pctenv = make_pkt(expectedseqnum,ACK,chksum)
udt_send(pctenv)
expectedseqnum++

apenas ACK: sempre envia ACK para pct recebido

corretamente com # seq. mais alto em ordem
• pode gerar ACKs duplicados
• só precisa se lembrar de expectedseqnum
• pacote fora de ordem:
o descarta (não mantém em buffer) -> sem buffering no
destinatário!
o reenvia ACK do pct com # seq. mais alto em ordem

slide 46
 GBN em operação

slide 47
 Repetição seletiva

• destinatário reconhece individualmente todos os

pacotes recebidos de modo correto
o mantém pcts em buffer, se for preciso, para eventual
remessa em ordem para a camada superior
• remetente só reenvia pcts para os quais o ACK não
foi recebido
o temporizador no remetente para cada pct sem ACK
• janela do remetente
o N # seq. consecutivos
o novamente limita #s seq. de pcts enviados, sem ACK

slide 48
 Repetição seletiva: janelas
de remetente, destinatário

slide 49
 Repetição seletiva
remetente
dados de cima:
• se próx. # seq. disponível na
janela, envia pct
timeout(n):
• reenvia pct n, reinicia
temporizador
ACK(n) em
[sendbase,sendbase+N]:
• marca pct n como recebido
• se n menor pct com ACK,
avança base da janela para
próximo # seq. sem ACK
slide 50
destinatário
pct n em [rcvbase, rcvbase+N-1]
• envia ACK(n)
• fora de ordem: buffer
• em ordem: entrega
(também entrega pcts em
ordem no buffer), avança
janela para próximo pct
ainda não recebido
pct n em [rcvbase-N,rcvbase-1]
• ACK(n)
caso contrário:
• ignora
 Repetição seletiva em
operação

slide 51
 Repetição seletiva:
dilema
Exemplo:
• # seq.: 0, 1, 2, 3
• tamanho janela = 3
• destinatário não vê diferença
nos dois cenários!
• passa incorretamente dados
duplicados como novos em
(a)

P: Qual o relacionamento entre

tamanho do # seq. e tamanho de
janela?

slide 52
 Esboço

• Serviços da camada de • Transporte orientado para

transporte conexão: TCP
• Multiplexação e o estrutura de segmento
demultiplexação o transferência confiável de
dados
• Transporte não o controle de fluxo
orientado para conexão: o gerenciamento da conexão
UDP • Princípios de controle de
• Princípios da congestionamento
transferência confiável • Congestionamento no TCP
de dados

slide 3
 TCP: Visão geral
RFCs: 793, 1122, 1323, 2018, 2581
• ponto a ponto:
o um remetente, um destinatário
• cadeia de bytes confiável, em
ordem:
o sem “limites de mensagem”
• paralelismo:
o congestionamento TCP e
controle de fluxo definem
tamanho da janela
• buffers de envio & recepção
slide 54
• dados full duplex:
o dados bidirecionais fluem na
mesma conexão
o MSS: tamanho máximo do
segmento
• orientado a conexão:
o apresentação (troca de msgs
de controle) inicia estado do
remetente e destinatário
antes da troca de dados
• fluxo controlado:
o remetente não sobrecarrega
destinatário
 Estrutura do segmento TCP
32 bits
URG: dados urgentes contagem por
(quase não usado) porta origem porta destino bytes de dados
(não segmentos!)
ACK: # ACK número sequência
válido número reconhecimento
compr. não
cab. usado
U AP R S F janela recepção # bytes
PSH: push dados p/ cima destinatário
agora (quase não usado) soma verificação ponteiro dados urg. pode aceitar
RST, SYN, FIN: opções (tamanho variável) quase sempre
estab. conexão vazio,negocia
(comandos setup, MSS ou opções
teardown) p/ high speed
dados da
soma de verificação
da Internet aplicação
(como em UDP) (tamanho variável)

slide 55
 #s sequência e ACKs do TCP

#’s de sequência:
• “número” na cadeia de bytes
do 1o byte nos dados do
segmento
ACKs:
• # seq do próximo byte
esperado do outro lado
• ACK cumulativo
P: como o destinatário trata
segmentos fora de ordem
• R: TCP não diz – a critério do
implementador

cenário telnet simples

slide 56
 Tempo de ida e volta e
timeout do TCP
P: Como definir o valor P: Como estimar o RTT?
de timeout do TCP? • SampleRTT: tempo medido
• maior que RTT da transmissão do segmento
o mas RTT varia até receber o ACK
• muito curto: timeout o ignora retransmissões
prematuro • SampleRTT variará;
o retransmissões queremos RTT estimado
desnecessárias “mais estável”
• muito longo: baixa o média de várias medições
reação a perda de recentes, não apenas
segmento SampleRTT atual

slide 57
 EstimatedRTT = (1-α)*EstimatedRTT + α *SampleRTT

• média móvel exponencial ponderada

• influência da amostra passada diminui exponencialmente
rápido
• valor típico: α = 0,125

slide 58
 Amostras de RTTs estimados:

slide 59
 Tempo de ida e volta e
timeout do TCP
definindo o timeout
• EstimtedRTT mais “margem de segurança”
o grande variação em EstimatedRTT -> maior margem de seg.
• primeira estimativa do quanto SampleRTT se desvia de
EstimatedRTT:

DevRTT = (1- α)*DevRTT +

α *|SampleRTT-EstimatedRTT|

(geralmente, α = 0,25)

depois definir intervalo de timeout

TimeoutInterval = EstimatedRTT + 4*DevRTT

slide 60
 Transferência confiável
de dados no TCP
• TCP cria serviço rdt em • retransmissões são
cima do serviço não disparadas por:
confiável do IP o eventos de timeout
• segmentos em paralelo o ACKs duplicados
• ACKs cumulativos • inicialmente, considera
• TCP usa único remetente TCP
temporizador de simplificado:
o ignora ACKs duplicados
retransmissão o ignora controle de fluxo,
controle de
congestionamento

slide 62
 Eventos de remetente TCP:
dados recebidos da apl.: timeout:
• cria segmento com • retransmite segmento
#seq que causou timeout
• #seq é número da • reinicia temporizador
cadeia de bytes do ACK recebido:
primeiro byte de dados • Reconhecem-se
no segmento segmentos sem ACK
• inicia temporizador, se anteriores
ainda não tiver iniciado o atualiza o que
(pense nele como para sabidamente tem ACK
o inicia temporizador se
o segmento mais antigo houver segmentos
sem ACK) pendentes
• intervalo de expiração:
TimeOutInterval

slide 63
 RemetenteTCP (simplificado)
NextSeqNum = InitialSeqNum
SendBase = InitialSeqNum

loop (forever) {
switch(event)

event: data received from application above

create TCP segment with sequence number NextSeqNum Comentário:
if (timer currently not running) • SendBase-1: último byte
start timer
pass segment to IP
cumulativo com ACK
NextSeqNum = NextSeqNum + length(dados) Exemplo:
• SendBase-1 = 71;
event: timer timeout y = 73, de modo que
retransmit not-yet-acknowledged segment with
smallest sequence number destinatário deseja 73+ ;
start timer y > SendBase, de modo
que novos dados têm ACK
event: ACK received, with ACK field value of y
if (y > SendBase) {
SendBase = y
if (there are currently not-yet-acknowledged segments)
start timer
}

} /* end of loop forever */

slide 64
 TCP: cenários de
retransmissão
Hosp. A Hosp. B Hosp. A Hosp. B

Seq = 92, 8 bytes dados Seq = 92, 8 bytes dados

Seq = 100, 20 bytes dados

ACK = 100 Seq = 92 timeout
timeout
X ACK = 100
ACK =
loss 120

Seq = 92, 8 bytes dados Sendbase Seq = 92, 8 bytes dados

= 100
SendBase
= 120 ACK =
Seq = 92 timeout
ACK = 120
100
SendBase
= 100 SendBase
= 120 Timeout prematuro
tempo tempo
Cenário de ACK perdido
slide 65
 Host A Host B

Seq = 92, 8 bytes dados

ACK = 100
timeout Seq = 100, 20 bytes dados
X
perda

SendBase ACK =
= 120 120

tempo
Cenário ACK cumulativo

slide 66
 Dobrando timeout
• Modificação comum
• Após um timeout dobra tempo de time out anterior em
vez de usar EstimtedRTT

slide 60
 TCP: geração de ACK
[RFC 1122, RFC 2581]

slide 67
 Retransmissão rápida

• período de timeout • se remetente recebe 3 ACKs

relativamente grande: para os mesmos dados, ele
o longo atraso antes de supõe que segmento após
reenviar pacote perdido dados com ACK foi perdido:
• detecta segmentos perdidos o retransmissão rápida: reenvia
por meio de ACKs duplicados segmento antes que o
o remetente geralmente envia temporizador expire
muitos segmentos um após
o outro
o se segmento for perdido,
provavelmente haverá
muitos ACKs duplicados
para esse segmento

slide 68
 Hosp. A Hosp. B

seq # x1
seq # x2
seq # x3 ACK x1
seq # x4 X
seq # x5
ACK x1
ACK x1
ACK x1
ACKs
duplicados
três vezes
reenvia seq X2

timeout

tempo

slide 69
 Algoritmo de retransmissão
rápida:
event: ACK received, with ACK field value of y
if (y > SendBase) {
SendBase = y
if (there are currently not-yet-acknowledged segments)
start timer
}
else {
increment count of dup ACKs received for y
if (count of dup ACKs received for y = 3) {
resend segment with sequence number y
}

ACK duplicado para retransmissão rápida

segmento já com ACK

slide 70