Inhalt der Vorlesung Rechnerkommunikation

Inhalt der Vorlesung Rechnerkommunikation Einführung Anwendungsschicht Transportschicht Netzwerkschicht Sicherungsschicht Physikalische Schicht Netzwerksicherheit Rechnerkommunikation, Transportschicht 1

Transportschicht Einführung UDP Fehlerkontrolle Stop-and-Wait Go-Back-N und Selective Repeat Leistungsanalyse TCP Segmentformat Fehlerkontrolle Verbindungsauf- und -abbau Schätzung der RTT Fluss- und Überlastkontrolle Leistungsanalyse Rechnerkommunikation, Transportschicht 2

Einführung Aufgabe der Transportschicht: Kommunikation zwischen Anwendungsprozessen = socket = process application P3 P1 P1 application P2 P4 application transport transport transport network network network link link link physical physical host 1 host 2 host 3 physical Rechnerkommunikation, Transportschicht 3

Einführung mögliche Dienstmerkmale Fehlerkontrolle Bewahrung der Reihenfolge verbindungslos/verbindungsorientiert Fluss- und Überlastkontrolle Garantien für Dienstgüte (z.b. Bitrate, Verzögerung, Verlust) User Datagram Protocol (UDP) verbindungslos, keine Kontrollmechanismen, bewahrt nicht Reihenfolge Schnittstelle für einfache Paketvermittlung mittels IP, Verantwortung für Kontrollmechanismen bei Anwendung Transmission Control Protocol (TCP) verbindungsorientiert, Fehler-, Fluss-, Überlastkontrolle, keine Dienstgütegarantien bietet Abstraktion eines Bytestroms Rechnerkommunikation, Transportschicht 4

UDP Segment: source port: Quellportnummer (16 Bit) dest port: Zielportnummer (16 Bit) length: Länge des gesamten Segments (16 Bit) checksum: Prüfsumme (16 Bit) für mögliche Fehlerkontrolle, Benutzung ist optional, 0000000000000000 2 bedeutet: ungenutzt Frage: wo befinden sich Quell- und Ziel-IP-Adresse? source port # dest port # length 32 bits Application data (message) checksum Rechnerkommunikation, Transportschicht 6

UDP Multiplexen und Demultiplexen Multiplexen: Zusammenführen der Segmente verschiedener Anwendungsprozesse durch Transportschicht auf dem Quellhost Demultiplexen: Ausliefern der Segmente an die verschiedenen Anwendungsprozesse durch Transportschicht des Zielhosts Anwendungsprozess vereinbart mit Transportschicht auf Quellhost Quellportnummer (wird entweder durch Anwendung gewählt oder ein freier Port wird vom Betriebssystem geliefert) realisiert z.b. durch Socket-API: DatagramSocket serversocket = new DatagramSocket(6428); serversocket.send(apacket); UDP auf dem Zielhost erkennt an Zielportnummer (und nur daran), zu welcher Anwendung das Segment geliefert werden soll ein Anwendungsprozess kann mehrere Sockets besitzen Rechnerkommunikation, Transportschicht 7

UDP Multiplexen und Demultiplexen, Beispiel: P2 P3 P1P1 SP: 6428 DP: 9157 SP: 6428 DP: 5775 SP: 9157 DP: 6428 SP: 5775 DP: 6428 Rechnerkommunikation, Transportschicht 8

UDP Berechnung der Prüfsumme Segment wird als Folge von Dualzahlen der Länge 16 Bit aufgefaßt diese werden in Einerkomplementarithmetik addiert - -x entsteht aus x durch Invertierung aller Bits - entsteht ein Übertrag, wird das Ergebnis inkrementiert das Ergebnis wird invertiert, dies ist die Prüfsumme der Sender berechnet die Prüfsumme und schreibt sie in das Segment der Empfänger berechnet in gleicher Weise die Prüfsumme und addiert in Einerkomplementarithmetik die aus dem Segment gelesene Prüfsumme falls kein Bitfehler vorliegt, ergibt sich als Ergebnis 1111111111111111 2, die Einerkomplement-Repräsentation von 0 einzelne Bitfehler werden erkannt, doppelte nicht es gibt bessere Fehlererkennungsmechanismen Rechnerkommunikation, Transportschicht 9

UDP Berechnung der Prüfsumme, Beispiel: 1 1 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 1 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 Übertrag Summe Prüfsumme 1 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1 1 1 0 1 1 1 0 1 1 1 0 1 1 1 1 0 0 1 0 1 0 0 0 1 0 0 0 1 0 0 0 0 1 1 Rechnerkommunikation, Transportschicht 10

UDP Pseudo-Header es ist in Wirklichkeit noch ein bißchen komplizierter... Pseudo-Header enthält Quell- und Ziel-IP-Adresse, Protokollnummer (17 für UDP) und Segmentlänge UDP des Senders schreibt zunächst 0 in das Checksum-Feld, erstellt einen Pseudo-Header und berechnet die Prüfsumme zusammen für das UDP-Segment und den Pseudo-Header diese Prüfsumme wird in das Checksum-Feld geschrieben dann wird das Segment und der Pseudo-Header an IP weitergereicht UDP des Empfängers erhält von IP das UDP-Segment und den Pseudo- Header, schreibt 0 in das Checksum-Feld und berechnet die Prüfsumme für Segment und Pseudo-Header Vorteil: die Kontrolle der Prüfsumme erkennt auch Fehler in den IP- Adressen, z.b. fehlgeleitete Segmente Nachteil: Verletzung des Schichtenprinzips (aber nur auf Endsystem) Rechnerkommunikation, Transportschicht 11

UDP Bitfehlerwahrscheinlichkeiten sei die Wahrscheinlichkeit eines einzelnen Bitfehlers p = 10-7 sei die Segmentlänge N = 10 4 Bits übliche vereinfachende Annahme (um überhaupt rechnen zu können): die Bitfehler der einzelnen Bits sind unabhängig voneinander Wahrscheinlichkeit für mindestens einen Bitfehler im Segment: 1-(1-p) N =0,00099950 10 4 10-7 = 10-3 Wahrscheinlichkeit für zwei Bitfehler im Segment: - Anzahl Paare: N 1 i= 1 i = (N 1) N / 2 = 1) 10 / 2 10 - Wahrscheinlichkeit, daß ein bestimmtes Paar fehlerhaft ist: 10-14 - Wahrscheinlichkeit, daß ein beliebiges Paar fehlerhaft ist: 10 8 10-14 /2 = 10-6 /2 wie lange dauert es im Mittel, bis ein Segment mit zwei Bitfehlern auftritt bei a) 10 Mbps und b) 10 Gbps? (10 4 4 8 / 2 Rechnerkommunikation, Transportschicht 12

Fehlerkontrolle Host A Host B Sendeprozeß Empfangsprozeß unzuverlässiger Kanal Rauschen, Pufferüberläufe, Ausfälle von Komponenten verursachen Bitfehler und Paketverluste kann durch Protokoll mit Fehlererkennung, Bestätigungen und Sendewiederholungen ausgeglichen werden Rechnerkommunikation, Transportschicht 14

Fehlerkontrolle Host A Host B Sendeprozeß Empfangsprozeß reliable data transfer protocol rdt_send(data) udt_send(pkt) udt_rcv(ack) rdt_rcv(data) reliable data transfer protocol udt_send(ack) unzuverlässiger Kanal Bitfehler, Paketverlust Rechnerkommunikation, Transportschicht 15

Fehlerkontrolle 3 grundlegende Protokolle für zuverlässigen Transport Stop-and-Wait - Sender fügt zur Fehlererkennung Prüfsumme oder besser Cyclic Redundancy Check (CRC) zu - Empfänger schickt Bestätigung (acknowledgment, ACK) - wenn diese nach einem Timeout nicht eintrifft, wird das Paket erneut gesendet - dadurch können evtl. Duplikate gesendet werden, um diese zu erkennen, benötigt man noch Sequenznummern (SQN) - bei großem Bandbreiten-Verzögerungsprodukt: Sender ist die meiste Zeit blockiert, ineffizient Schiebefensterprotokolle (sliding window protocols) - mehrere Pakete auf einmal senden, um Kanal zu füllen - Go-Back-N und Selective Repeat - unterscheiden sich bei Timeout, Bestätigungen, Sendewiederholung Rechnerkommunikation, Transportschicht 16

Stop-and-Wait wie funktioniert nun Stop-and-Wait genau? zunächst eine informelle Beschreibung: Verhalten des Senders 1. sende Paket mit aktueller SQN und starte Timer 2. wenn ein ACK ohne Bitfehler und mit aktueller SQN vor Ablauf des Timeouts zurückkommt, inkrementiere SQN und gehe zu 1 3. wenn der Timeout abläuft, sende das Paket erneut, starte den Timer erneut und gehe zu 2 Verhalten des Empfängers - wenn Paket ohne Bitfehler und mit aktueller SQN ankommt, sende ACK mit aktueller SQN und inkrementiere SQN, sonst sende das letzte ACK erneut Rechnerkommunikation, Transportschicht 18

Stop-and-Wait Beschreibung durch UML-Statecharts ein Statechart befindet sich immer in einem Zustand, der schwarze Punkt kennzeichnet den initialen Zustand ein Zustandsübergang findet statt, wenn das Ereignis ausgelöst wurde und die Bedingung erfüllt ist wenn ein Zustandsübergang stattfindet, wird die Aktion durchgeführt zur Steigerung der Flexibilität gibt es auch Variablen Ereignis[Bedingung]/Aktion /Aktion Zustand 1 Zustand 2 Rechnerkommunikation, Transportschicht 19

Stop-and-Wait Bemerkungen zu den Statecharts Statecharts stellen eine Variante von endlichen Automaten dar Ereignisse, Bedingungen und Aktionen werden oft durch Pseudocode beschrieben, man erhält eine halbformale Beschreibung das Verhalten von Protokollen wird oft durch solche oder ähnliche Automaten dargestellt es gibt auch Werkzeuge, die dies unterstützen: Protokolle können so spezifiziert werden und daraus der Code generiert werden sowie Analysen, Simulationen und Tests durchgeführt werden man kann daraus gut Implementierungen ableiten: eine große Fallunterscheidung für die möglichen Ereignisse in den verschiedenen Zuständen hier werden Statecharts einfach zur genauen Darstellung des Stop-and- Wait-Protokolls und später von weiteren Protokollen verwendet die Darstellung ist durch Kurose/Ross motiviert, unterscheidet sich aber von den Automaten in dem Buch Rechnerkommunikation, Transportschicht 20

Stop-and-Wait Sender: /SQN=1 udt_rcv(ack)/ data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ ACK udt_rcv(ack) [biterror(ack) SQN(ACK) SQN]/ timeout/ udt_send(pkt); start_timer Rechnerkommunikation, Transportschicht 21

Stop-and-Wait Empfänger: /SQN=1 packet [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ [biterror(pkt) SQN(pkt) SQN]/ udt_send(ack) Rechnerkommunikation, Transportschicht 22

/SQN=1 Stop-and-Wait: normaler Ablauf data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) SQN(ACK) SQN)]/ [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN =? SQN =? Rechnerkommunikation, Transportschicht 23 time

/SQN=1 Stop-and-Wait: normaler Ablauf data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 1 SQN = 1 Rechnerkommunikation, Transportschicht 24 time

/SQN=1 Stop-and-Wait: normaler Ablauf data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 1 SQN = 21 time Rechnerkommunikation, Transportschicht 28

/SQN=1 Stop-and-Wait: Paketverlust data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 2 SQN = 2 Rechnerkommunikation, Transportschicht 31 time

/SQN=1 Stop-and-Wait: Verlust eines ACKs data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 3 SQN = 3 Rechnerkommunikation, Transportschicht 39 time

/SQN=1 data udt_rcv(ack)/ Stop-and-Wait: Verlust eines ACKs rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ timeout/ udt_send(pkt); start_timer [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) /SQN=1 SQN = 3 SQN = 4 Rechnerkommunikation, Transportschicht 44 time

/SQN=1 data udt_rcv(ack)/ Stop-and-Wait: Verlust eines ACKs rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ timeout/ udt_send(pkt); start_timer [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) /SQN=1 Duplikat! SQN = 3 SQN = 4 Rechnerkommunikation, Transportschicht 45 time

/SQN=1 Stop-and-Wait: verzögertes ACK data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 4 SQN = 4 Rechnerkommunikation, Transportschicht 49 time

/SQN=1 data udt_rcv(ack)/ Stop-and-Wait: verzögertes ACK rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ timeout/ udt_send(pkt); start_timer [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) SQN = 4 SQN = 5 Rechnerkommunikation, Transportschicht 55 time /SQN=1 Duplikat!

/SQN=1 data udt_rcv(ack)/ Stop-and-Wait: verzögertes ACK rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ timeout/ udt_send(pkt); start_timer [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) /SQN=1 Duplikat! SQN = 5 SQN = 5 Rechnerkommunikation, Transportschicht 58 time

/SQN=1 Stop-and-Wait: verzögertes ACK data rdt_send(data)/ pkt=pkt(sqn,data,crc); udt_send(pkt); start_timer ACK udt_rcv(ack) [biterror(ack) v SQN(ACK) SQN)]/ [ biterror(pkt) SQN(pkt)=SQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(SQN,CRC); udt_send(ack); SQN++ paket /SQN=1 udt_rcv(ack)/ udt_rcv(ack) [ biterror(ack) SQN(ACK)=SQN]/ stop_timer; SQN++ timeout/ udt_send(pkt); start_timer [biterror(pkt) v SQN(pkt) SQN]/ udt_send(ack) Duplikat! SQN = 5 SQN = 5 Rechnerkommunikation, Transportschicht 60 time

Stop-and-Wait Sequenznummerraum die Repräsentation der Sequenznummern ist endlich: ein Feld mit n Bits ermöglicht 2 n Sequenznummern Wiederverwendung durch zyklisches Durchlaufen für Stop-and-Wait ist ein Bit zur Darstellung von 2 Sequenznummern ausreichend: 0 und 1 Stop-and Wait mit 0 und 1 als Sequenznummern heißt auch Alternating-Bit-Protokoll Rechnerkommunikation, Transportschicht 61

Go-Back-N und Selective Repeat Um die Ineffizienz von Stop-and-Wait zu vermeiden, senden Schiebefensterprotokolle mehrere Pakete, bevor die Bestätigung zurückkommt: Datenpakete Datenpakete ACKs Stop-and-Wait Schiebefensterprotokoll Rechnerkommunikation, Transportschicht 63

Go-Back-N Überblick über Go-Back-N der Sender darf mehrere Pakete (bis zu einer Maximalzahl) vor Erhalt eines ACKs senden er startet beim Senden des ersten Pakets einen Timer er puffert die unbestätigten Pakete wenn der Timer abläuft, werden alle unbestätigten Paket erneut gesendet der Empfänger schickt kumulative ACKs: ein ACK mit einer SQN bedeutet, daß alle Pakete bis zu der SQN erfolgreich empfangen wurden der Empfänger akzeptiert nur Pakete in der richtigen Reihenfolge und benötigt keinen Puffer Rechnerkommunikation, Transportschicht 64

Go-Back-N Sendepuffer nextsqn 1 2 3 4 5 6 7 8 base base+w-1 base: SQN des ältesten unbestätigten Pakets nextsqn: SQN des nächsten zu verschickenden Pakets W: Fenstergröße, Anzahl der Pakete, die Sender vor Erhalt eines ACKs senden darf das Fenster [base, base+w-1] wird beim Ablauf des Protokolls von links nach rechts verschoben, wegen der kumulativen ACKs hat es immer folgende Struktur: - [base, nextsqn-1]: versendete unbestätigte Pakete - [nextsqn, base+w-1]: bisher ungesendete Pakete, die vor Erhalt eines ACKs noch gesendet werden dürfen Rechnerkommunikation, Transportschicht 65

Go-Back-N informelle Beschreibung des Protokolls Verhalten des Senders 1. wenn Daten zum Senden und Platz im Fenster: sende Paket mit nextsqn und inkrementiere nextsqn; wenn es das erste Paket im Fenster ist, starte Timer 2. wenn ein ACK ohne Bitfehler und mit SQN im Fenster zurückkommt, schiebe das Fenster bis zu dieser SQN; wenn das Fenster leer ist, stoppe den Timer, sonst starte den Timer neu 3. wenn der Timeout abläuft, sende alle unbestätigten Pakete des Fensters erneut, starte den Timer erneut Verhalten des Empfängers - wenn Paket ohne Bitfehler und mit aktueller SQN ankommt, sende ACK mit aktueller SQN und inkrementiere SQN, sonst sende das letzte ACK erneut (wie bei Stop-and-Wait) Rechnerkommunikation, Transportschicht 66

Go-Back-N Beschreibung durch Statecharts neues Element: Verzweigung [Bedingung1]/Aktion1 [Bedingung2]/Aktion2 Zustand, in dem keine Zeit verbracht wird ( Pseudozustand ) abgehende Zustandsübergänge werden mittels Bedingungen gewählt, auslösende Ereignisse sind hier nicht möglich Rechnerkommunikation, Transportschicht 67

Go-Back-N: Sender [nextsqn base+w]/ signal refusal to upper layer [nextsqn<base+w]/ pkt[nextsqn]=pkt(nextsqn,data,crc); udt_send(pkt[nextsqn]); if base=nextsqn start_timer; nextsqn++ /base=1; nextsqn=1 udt_rcv(ack) [biterror(ack) SQN(ACK))<base nextsqn SQN(ACK)]/ wait rdt_send(data) timeout/ udt_send(pkt[base]); udt_send(pkt[base+1]); udt_send(pkt[nextsqn-1]); start_timer udt_rcv(ack) [ biterror(ack) base SQN(ACK)<nextSQN]/ base=sqn(ack)+1; if base=nextsqn stop_timer else start_timer Rechnerkommunikation, Transportschicht 68

Go-Back-N: Empfänger /expectedsqn=1; ACK=ACK(0,CRC) packet [ biterror(pkt) SQN(pkt)=expectedSQN]/ data=extractdata(pkt); rdt_rcv(data); ACK=ACK(expectedSQN,CRC); udt_send(ack); expectedsqn++ [biterror(pkt) SQN(pkt) expectedsqn]/ udt_send(ack) Rechnerkommunikation, Transportschicht 69

Go-Back-N: normaler Ablauf am Anfang 1 2 3 4 5 6 7 8 Paket 1 gesendet 1 2 3 4 5 6 7 8 Paket 2 gesendet Paket 3 gesendet, Sender blockiert ACK 1 empfangen ACK 2 empfangen 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 Paket 1 übergeben Paket 2 übergeben Paket 3 übergeben Paket 4 gesendet 1 2 3 4 5 6 7 8 Rechnerkommunikation, Transportschicht 70

Go-Back-N: Paketverlust 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 Paket 1 übergeben Timer neu starten 1 2 3 4 5 6 7 8 Ablauf des Timers, alle unbestätigten Pakete erneut senden Paket 2 übergeben Paket 3 übergeben 1 2 3 4 5 6 7 8 Paket 4 übergeben

Go-Back-N: Verlust und Verspätung von ACKs 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 Paket 1 übergeben Paket 2 übergeben Paket 3 übergeben kumulatives ACK gleicht Verlust und Verspätung aus 1 2 3 4 5 6 7 8 Rechnerkommunikation, Transportschicht 72

Selective Repeat Überblick über Selective Repeat der Sender darf wieder mehrere Pakete (bis zu einer Maximalzahl) vor Erhalt eines ACKs senden er startet beim Senden jedes Pakets einen Timer er puffert die unbestätigten Pakete wenn der Timer für ein Paket abläuft, wird dieses Paket erneut gesendet der Empfänger schickt selektive ACKs: ein ACK mit einer SQN bedeutet nur, daß das Paket mit der SQN erfolgreich empfangen wurde der Empfänger benötigt einen Puffer zum Ausgleich von Lücken beim Empfang Rechnerkommunikation, Transportschicht 73

Selective Repeat: Sende- und Empfängerpuffer nextsqn Sendeseite: 1 2 3 4 5 6 7 8 Empfängerseite: 1 2 3 4 5 6 7 8 base base+w-1 base base+w-1 base, nextsqn, W: wie bei Go-Back-N das Fenster auf Sendeseite enthält versendete unbestätigte, versendete bestätigte und ungesendete Pakete der Empfänger puffert die empfangenen Pakete das Fenster auf Empfängerseite enthält empfangene Pakete und Lücken und Platz für unempfangene Pakete Rechnerkommunikation, Transportschicht 74

Selective Repeat informelle Beschreibung des Protokolls Verhalten des Senders 1. wenn Daten zum Senden und Platz im Fenster: sende Paket, starte Timer für dieses Paket und inkrementiere nextsqn 2. wenn ein ACK ohne Bitfehler und mit SQN im Fenster zurückkommt, markiere das Paket mit SQN als bestätigt, schiebe das Fenster bis zur nächsten Lücke 3. wenn der Timeout für das Paket mit SQN abläuft, sende dieses Paket erneut, starte den Timer für dieses Paket erneut Verhalten des Empfängers - wenn Paket ohne Bitfehler und mit SQN im Fenster ankommt, sende ACK mit dieser SQN, puffere das Paket und schiebe das Fenster bis zur nächsten Lücke - wenn Paket mit SQN aus vorigem Fenster ankommt, sende das ACK hierfür erneut Rechnerkommunikation, Transportschicht 75

Selective Repeat: Sender [nextsqn base+w]/ signal refusal to upper layer [nextsqn<base+w]/ pkt[nextsqn]=pkt(nextsqn,data,crc); udt_send(pkt[nextsqn]); start_timer[nextsqn]; nextsqn++ /base=1; nextsqn=1 rdt_send(data) udt_rcv(ack) [biterror(ack) SQN(ACK)<base nextsqn SQN(ACK)]/ wait timeout[sqn]/ udt_send(pkt[sqn]); start_timer[sqn] udt_rcv(ack) [ biterror(ack) base SQN(ACK)<nextSQN]/ SQN=SQN(ACK); mark pkt[sqn] as received; if SQN=base move base to next unacked packet; stop_timer[sqn] Rechnerkommunikation, Transportschicht 76

Selective Repeat: Empfänger /base=1 packet [ biterror(pkt) SQN(pkt) in [base,base+w-1]]/ data=extractdata(pkt); buffer data; if SQN(pkt)=base base=lowest unrcvd sequence number; deliver all data until base-1; ACK=ACK(SQN(pkt),CRC); udt_send(ack) [biterror(pkt) SQN(pkt) not in [base-w,base-1]/ [ biterror(pkt) SQN(pkt) in [base-w,base-1]]/ ACK=ACK(SQN(pkt),CRC); udt_send(ack) Rechnerkommunikation, Transportschicht 77

Selective Repeat: normaler Ablauf 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 Rechnerkommunikation, Transportschicht 78

Selective Repeat: Paketverlust 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 Rechnerkommunikation, Transportschicht 79

Selective Repeat: Verlust eines ACKs 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 Rechnerkommunikation, Transportschicht 80

Selective Repeat Sequenznummerraum bei Schiebefensterprotokollen endliches Sequenznummerfeld mit m Werten zyklisches Durchlaufen: Wiederverwendung von SQN unterschiedliche Pakete mit gleicher SQN müssen unterschieden werden hinreichende Bedingungen dafür: - falls Empfangsfenstergröße = 1: W < m - falls Sendefenstergröße = Empfangsfenstergröße = W > 1: W < (m+1)/2 Beispiel für zu kleinen Sequenznummerraum m = 4 Sequenznummern, Fenstergröße W = 3 W > (m+1)/2 Empfänger kann nicht unterscheiden, ob Paket 0 alt oder neu ist, siehe nächste Seite Rechnerkommunikation, Transportschicht 81

Selective Repeat zwei mögliche Abläufe für m=4 und W=3, die für den Empfänger nicht unterscheidbar sind und zu unterschiedlichen Ergebnissen führen: 0 1 2 3 0 1 2 0 1 2 3 0 1 2 hier wird altes Paket 0 fälschlicherweise für neu gehalten 0 1 2 3 0 1 2 0 1 2 3 0 1 2 0 1 2 3 0 1 2 0 1 2 3 0 1 2 0 1 2 3 0 1 2 0 1 2 3 0 1 2 hier wird neues Paket 0 korrekterweise für neu gehalten 0 1 2 3 0 1 2 0 1 2 3 0 1 2 0 1 2 3 0 1 2 0 1 2 3 0 1 2 Rechnerkommunikation, Transportschicht 82

Vergleich von Go-Back-N und Selective Repeat Vorteile Go-Back-N kumulative ACKs gleichen ACK-Verluste und -Verspätungen schnell aus, ohne daß die Pakete erneut gesendet werden müssen der Sender benötigt nur einen Timer der Empfänger benötigt keinen Puffer Sender und Empfänger können einfacher realisiert werden, weil keine Lücken in den Fenstern beachtet werden müssen Vorteil Selective Repeat weniger Wiederholungen von Sendungen, weil nur wirklich fehlerhafte oder verlorengegangene Pakete erneut gesendet werden Rechnerkommunikation, Transportschicht 83

Leistungsanalyse Fragen wann tritt bei Stop-and-Wait eine Senderblockade ein und wie stark wird der mögliche Durchsatz verkleinert? wie groß muß bei Schiebefensterprotokollen das Fenster sein, um den Kanal zu füllen? ist Go-Back-N oder Selective Repeat effizienter? im folgenden analytische Betrachtung aus W. Stallings: Computer Networking with Internet Protocols and Technology, Pearson Education, 2004 und W. Stallings: High-Speed Networks, TCP/IP and ATM Design Principles, Prentice Hall, 1998 Beispiel für typische Leistungsanalyse von Kommunikationssystemen einige vereinfachende Annahmen sind nötig, um rechnen zu können die mathematischen Ausdrücke sind gar nicht so schlimm bei Go-Back-N benötigen wir die meisten Vereinfachungen und schwierigsten Ausdrücke noch genauere Untersuchungen sind mit Simulation möglich Rechnerkommunikation, Transportschicht 85

Leistungsanalyse: Produkt aus Bitrate und Verzögerung Produkt aus Bitrate und Verzögerung Bitrate R, Ausbreitungsverzögerung D vom Sender zum Empfänger einfacher Kanal, A sendet ohne Unterbrechung an B RD > 1: A A B B t = 0: A beginnt zu senden t = D: erstes Bit erreicht B, RD Bits sind mittlerweile gesendet RD < 1: A A B B t = 0: A beginnt zu senden t = D: der Anfang des Bits erreicht B, RD 100% des Bits sind mittlerweile gesendet A B t = 1/R: das Ende des Bits verläßt A A B t = 1/R + D: das Ende des Bits erreicht B Rechnerkommunikation, Transportschicht 86

Leistungsanalyse: Produkt aus Bitrate und Verzögerung Kanalpuffergröße in Bits D d / v R D = = = 1 /R 1 /R Ausbreitungsverzögerung Bitsendezeit = Anzahl gesendeter Bits während sich das erste Bit vom Sender zum Empfänger ausbreitet = Kanalpuffergröße in Bits Beispiel für RD > 1: - R = 100 Mbps, d = 4800 km, v = 3 10 8 m/s - RD = 100 10 6 bits s 3 4800 10 m 8 3 10 m / s = 1600 10 3 bits = 195,3KB Beispiel für RD < 1: - R = 10 Mbps, d = 10 m, v = 2 10 8 m/s 6 Bits 10m - RD = 10 10 = 0,5Bits 8 s 2 10 m / s Rechnerkommunikation, Transportschicht 87

Leistungsanalyse: Produkt aus Bitrate und Verzögerung Kanalpuffergröße in Paketen mit Paketgröße L: R D d / v a = = = L L /R Ausbreitungsverzögerung Paketsendezeit = Anzahl gesendeter Pakete während sich das erste Bit vom Sender zum Empfänger ausbreitet = Kanalpuffergröße in Paketen Rechnerkommunikation, Transportschicht 88

Leistungsanalyse: Produkt aus Bitrate und Verzögerung Normierung der Zeit durch Paketsendezeit (L/R = eine Zeiteinheit), dann - ist 1 Zeiteinheit die Zeit zum Senden eines Pakets (1 L/R) - sind a Zeiteinheiten die Ausbreitungsverzögerung (a L/R = RD/L L/R = D) t 0 A B t 0 A B t 0 +1 A pkt B t 0 +a A B t 0 +a A B t 0 +1 A B t 0 +1+a A B t 0 +1+a A B t 0 +1+2a A ACK B t 0 +1+2a A B a>1 a<1 Rechnerkommunikation, Transportschicht 89

einige Werte für a: Bitrate (Mbps) Paketgröße (Bits) Entfernung (km) 0,064 1000 0,1 0,00003 0,064 1000 1 0,0003 0,064 1000 35863 7,65 0,064 10.000 0,1 0,000003 0,064 10.000 1 0,00003 0,064 10.000 35863 0,77 1 1000 1 0,005 1 1000 3000 15 1 1000 35863 119,5 1 10.000 1 0,0005 1 10.000 3000 1,5 1 10.000 35863 11,95 10 1000 0,05 0,0025 10 1000 0,5 0,025 10 10.000 0,05 0,00025 10 10.000 0,5 0,0025 100 1000 0,1 0,05 100 10.000 0,1 0,005 1000 1000 0,1 0,5 1000 10.000 0,1 0,05 a Rechnerkommunikation, Transportschicht 90

Leistungsanalyse: Stop-and-Wait Stop-and-Wait ohne Fehler Vernachlässigung der ACK-Sendezeit und Bearbeitungszeiten (sinnvolle vereinfachende Annahme für diese Berechnungen) L/R 2D L/R 2D pro Zeit gesendete Bits: Durchsatz = L L /R + 2D normiert durch die Bitrate (gut für Vergleich bei verschiedenen Bitraten, vergleiche auch mit vorletzter Folie): L 1 1 1 normierter Durchsatz = S = = = L /R + 2D R 1 + 2RD /L 1 + 2a 1 S = 1+ 2a schlechter Durchsatz für große a (Kanal kann nicht gefüllt werden) Rechnerkommunikation, Transportschicht 91

Leistungsanalyse Stop-and-Wait Stop-and-Wait mit Fehlern Sendewiederholung nach einem Fehler (Timeout oder fehlerhaftes ACK) Annahme: Fehler treten unabhängig voneinander mit Wahrscheinlichkeit p auf (schon wieder eine Vereinfachung!) Timeout = 2D N ist die mittlere Anzahl, mit der jedes Paket gesendet werden muß, dann: Durchsatz L = N (L /R + 2D) S = L /R N (L /R + 2D) = 1 N (1+ 2RD /L) = 1 N (1+ 2a) Rechnerkommunikation, Transportschicht 92

Leistungsanalyse: Stop-and-Wait Berechnung von N: - die Wahrscheinlichkeit, daß ein Paket i-mal gesendet werden muß, ist gleich der Wahrscheinlichkeit von i-1 fehlerhaften Sendungen gefolgt von einem fehlerfreien Senden - Pr[i Sendeversuche] = p i-1 (1-p) - dies ist die geometrische Verteilung, Erwartungswert: - N = E[Sendeversuche] = i= 1 i p i 1 (1 p) 1 (1 p) (1 p) 2 = (1 p) 1 = 1 p i p - Einsetzen liefert den normalisierten Durchsatz: 1 p S = 1+ 2a i= 1 i= 1 i Pr[i Sendeversuche] = Rechnerkommunikation, Transportschicht 93 i 1 = (1 p) i= 0 i p 1 = (1 p) 1 p schlechter Durchsatz für große a und p =

Leistungsanalyse: Stop-and-Wait normierter Durchsatz von Stop-and-Wait als Funktion von a: für große a fällt der Durchsatz ab, für größere p ist der Durchsatz ebenfalls kleiner Rechnerkommunikation, Transportschicht 94

Rechnerkommunikation, Transportschicht 95 Leistungsanalyse: Schiebefensterprotokolle Schiebefensterprotokolle ohne Fehler für Fenstergröße mit W Paketen der Länge L Fall 1: das Fenster ist groß genug, um zu senden, bis ACK zurückkommt: - - Fall 2: das Fenster ist nicht groß genug - - a R L D R L W 2 1 / 2 / + = + 1 R 1 L /R W L W S = = 2a 1 W + < 2a 1 W R 1 2D L /R L W S + = + = + < + + = a W a W a W S 2 1 2 1 2 1 1

Leistungsanalyse: Schiebefensterprotokolle Zeitablauf beim Schiebefensterprotokoll t=0 A B 1 A pkt 1 B 2 a a+1 2a+1 A A pkt 2 pkt 1... pkt a pkt (a-1) pkt 2 pkt 1 A... A pkt (a+1) pkt a pkt 3 pkt 2... pkt (2a+1) pkt (2a) pkt (a+3) pkt (a+2) A W > 2a + 1 A B B B B Rechnerkommunikation, Transportschicht 96

Leistungsanalyse: Schiebefensterprotokolle t=0 1 a a+1 W 2a+1 A A A pkt 1... pkt a pkt (a-1) pkt 2 pkt 1 pkt (a+1) pkt a pkt 3 pkt 2 A... A A... pkt W pkt (W-1) pkt (W-a+2) pkt (W-a+1) A A pkt W... pkt (a+2) A B B B B B B W < 2a + 1 Rechnerkommunikation, Transportschicht 97

Leistungsanalyse: Schiebefensterprotokolle normierter Durchsatz von Schiebefensterprotokollen als Funktion von a: eine Fenstergröße W reicht bis zu einer maximalen Größe a = (W-1)/2, um den Kanal zu füllen, danach sinkt der Durchsatz Rechnerkommunikation, Transportschicht 98

Leistungsanalyse: Schiebefensterprotokolle Selective Repeat mit Fehlern Annahme: unabhängige Fehler mit Wahrscheinlichkeit p N = E[Sendeversuche] = 1/(1-p) der Durchsatz im fehlerfreien Fall muß durch N geteilt werden: S = 1 1 = = 1 p N 1 /(1 p) W W = N (1 + 2a) 1 /(1 p) (1 + 2a) = W(1 p) 1 + 2a W W 1 + < 1 + 2a 2a S = 1 p W(1 p) 1 + 2a W W 1 + < 1 + 2a 2a Rechnerkommunikation, Transportschicht 99

Leistungsanalyse: Schiebefensterprotokolle Go-back-N mit Fehlern jeder Fehler erfordert eine Sendewiederholung von K Paketen Annahme: im Fehlerfall ist das Fenster gefüllt und alle Pakete des Fensters müssen erneut gesendet werden, dann: K = 1 + 2a W W W 1 + < 1 + 2a 2a wenn das fehlerhafte Paket i-mal gesendet wird, müssen insgesamt 1+(i-1)K = (1-K)+Ki Pakete gesendet werden N = i= 1 ((1 K) + Ki) p i 1 (1 p) i = (1 K)(1 p) p + K(1 p) i= 0 K 1 p + Kp = 1 K + = 1 p 1 p = (1 K)(1 p) + K(1 p) Rechnerkommunikation, Transportschicht 100 i= 0 i p i= 1 p i 1 i= 1 i p i 1 1 1 = (1 K)(1 p) + K(1 p) 1 p (1 p) 2

Leistungsanalyse: Schiebefensterprotokolle mit K erhalten wir: N = 1 p + Kp 1 p 1 p + Kp 1 p = = 1 p + (1+ 2a)p 1 p 1 p + Wp 1 p = 1+ 2ap 1 p W W 1+ 2a < 1+ 2a Division des Durchsatzes ohne Fehler durch N ergibt: S = 1 1 p = N 1 + 2ap W = N (1 + 2a) (1 p W(1 p) + Wp) (1 + 2a) W W 1 + < 1 + 2a 2a S = 1 p 1 + 2ap W(1 p) (1 p + Wp) (1 + 2a) W W 1 + < 1 + 2a 2a Rechnerkommunikation, Transportschicht 101

Leistungsanalyse: Schiebefensterprotokolle normierter Durchsatz von G-Back-N und Selective Repeat als Funktion von a, p = 10-3 : erst für größere Fenster ergibt sich ein spürbarer Vorteil von Selective Repeat Rechnerkommunikation, Transportschicht 102

Leistungsanalyse: Schiebefensterprotokolle normierter Durchsatz von G-Back-N und Selective Repeat als Funktion von a, p = 10-2 : durch die höheren Verluste wird der der Vorteil von Selective Repeat jetzt auch bei kleineren Fenstergrößen sichtbar Rechnerkommunikation, Transportschicht 103

Leistungsanalyse: Schiebefensterprotokolle normierter Durchsatz von G-Back-N und Selective Repeat als Funktion von a, p = 10-1 : der Vorteil von Selective Repeat ist bei so vielen Verlusten deutlich Rechnerkommunikation, Transportschicht 104

Leistungsanalyse: Schiebefensterprotokolle normierter Durchsatz von G-Back-N und Selective Repeat als Funktion von W, p = 10-3 : für große a und große Fenster gibt es einen erheblichen Unterschied zwischen Go-Back-N und Selective Repeat Rechnerkommunikation, Transportschicht 105

Leistungsanalyse: Schiebefensterprotokolle normierter Durchsatz von G-Back-N und Selective Repeat als Funktion von W, p = 10-2 : der Unterschied wird deutlicher Rechnerkommunikation, Transportschicht 106

Leistungsanalyse: Schiebefensterprotokolle normierter Durchsatz von G-Back-N und Selective Repeat als Funktion von W, p = 10-1 : und noch deutlicher Rechnerkommunikation, Transportschicht 107

TCP Transmission Control Protocol das verbreitete zuverlässige Transportprotokoll im Internet RFCs 793, 1122, 1323, 2018, 2581 Punkt-zu-Punkt: ein Sender, ein Empfänger reihenfolgebewahrender Bytestrom fensterbasierte Fehlerkontrolle vollduplex: 2 entgegengesetzte Datenströme verbindungsorientiert: Auf- und Abbau einer Verbindung Flusskontrolle: Mechanismus, um Überschreitung der Kapazität des Empfängers zu verhindern Überlastkontrolle: Mechanismus, um Überlastung des Netzes zu verhindern Rechnerkommunikation, Transportschicht 109

TCP: Segmentformat sequence number: Nummer des ersten Bytes des Segments im Bytestrom ack. number: Nummer des nächsten erwarteten Bytes im Bytestrom Flags mit Steuerinformation: - URG (urgent pointer gültig) - ACK (ACK gültig) - PSH (Push Segment) - RST (Verbindung zurücksetzen) - SYN (synchronisiere Verbindung) - FIN (beende Verbindung) AdvertizedWindow: Fenstergröße für Flußsteuerung checksum: Prüfsumme (wie UDP) source port # dest port # head len 32 bits sequence number acknowledgment number not used U A P R S F checksum AdvertizedWindow Urg data pnter Options (variable length) application data (variable length) Rechnerkommunikation, Transportschicht 111

TCP Multiplexen und Demultiplexen TCP-Verbindung eindeutig gekennzeichnet durch 4-Tupel - Quell-IP-Adresse - Ziel-IP-Adresse - Quellportnummer - Zielportnummer realisiert z.b. durch Socket-API: ServerSocket welcomesocket = new ServerSocket(6789); Sockets sind unterschiedlich, falls mindestens ein Wert des 4-Tupels sich unterscheidet über einen Port können also viele TCP-Verbindungen laufen (z.b. Port 80 für Web-Server) Pseudo-Header wie in UDP, einschließlich Prüfsummenberechnung Rechnerkommunikation, Transportschicht 112

TCP Multiplexen und Demultiplexen, Beispiel: P1 P4 P5 P6 P2 P1P3 SP: 5775 DP: 80 S-IP: B D-IP:C SP: 9157 DP: 80 SP: 9157 DP: 80 A S-IP: A C S-IP: B B D-IP:C D-IP:C Rechnerkommunikation, Transportschicht 113

TCP: Fehlerkontrolle Fehlerkontrolle in TCP Mischform von Go-Back-N und Selective Repeat und weiterer Elemente - Puffer auf Sender- und Empfängerseite - ein Timer - kumulative ACKs - Sequenz- und ACK-Nummern beziehen sich nicht auf Pakete Sequenznummer = Position des ersten Bytes des Segments im Bytestrom ACK-Nummer = Position des nächsten erwarteten Bytes im Bytestrom diverse Implementierungsoptionen, im Folgenden wird eine vereinfachte Standardform beschrieben, wer mehr Einzelheiten verstehen möchte, sollte die RFCs lesen außerdem wird im Folgenden wegen der Übersichtlichkeit die Behandlung von Bitfehlern nicht beschrieben, sie können genauso wie bei Go-Back-N oder Selective Repeat behandelt werden Rechnerkommunikation, Transportschicht 115

TCP: Fehlerkontrolle Überblick über die Fehlerkontrolle bei TCP der Sender darf mehrere Segmente vor Erhalt eines ACKs senden (bis zu einer von verschiedenen Mechanismen abhängigen maximalen Gesamtzahl von Bytes) er startet beim Senden des ersten Segments eines Fensters einen Timer er puffert die unbestätigten Segmente wenn der Timer abläuft, wird das erste unbestätigte Segment des Fensters erneut gesendet der Empfänger schickt kumulative ACKs mit der Position des ersten noch nicht empfangenen Bytes das Fenster wird auf Sender- und Empfängerseite immer bis zur nächsten Lücke geschoben Rechnerkommunikation, Transportschicht 116

TCP: Fehlerkontrolle Sende- und Empfängerfenster nextsqn Sendeseite: 40-65 66-93 94-125 Empfängerseite: 40-65 66-81 82-93 94 base base+w base base+w base: erstes Byte des Fensters base+w: erstes Byte außerhalb des Fensters nextsqn: erstes Byte des nächsten noch nicht gesendeten Segments das Fenster auf Sendeseite enthält versendete unbestätigte und ungesendete Pakete das Fenster auf Empfängerseite enthält empfangene Pakete und Lücken und Platz für unempfangene Pakete Rechnerkommunikation, Transportschicht 117

TCP: Fehlerkontrolle informelle Beschreibung des Protokolls Verhalten des Senders 1. wenn Daten zum Senden und Platz im Fenster: erstelle Segment mit nextsqn und sende es mit IP, erhöhe nextsqn um Länge der Daten; wenn es das erste Paket im Fenster ist, starte Timer 2. wenn ein ACK mit ACK-Nr. im Fenster zurückkommt, schiebe das Fenster bis zu dieser ACK-Nr.; wenn das Fenster leer ist, stoppe den Timer, sonst starte den Timer neu 3. wenn der Timeout abläuft, sende das erste unbestätigte Paket des Fensters erneut, starte den Timer erneut Rechnerkommunikation, Transportschicht 118

TCP: Fehlerkontrolle Verhalten des Empfängers - wenn ein Segment ankommt und SQN = Fensteranfang ist und alle vorherigen Segmente bereits bestätigt sind: schiebe Fensteranfang bis zum nächsten erwarteten Byte und warte ein Timeout (500 ms), wenn bis dahin kein neues Segment ankommt, schicke ein ACK mit dem Fensteranfang (delayed ACK) SQN = Fensteranfang ist und ein vorheriges Segment noch nicht bestätigt wurde, schiebe Fensteranfang bis zum nächsten erwarteten Byte und schicke sofort ein kumulatives ACK mit dem Fensteranfang SQN > Fensteranfang ist, puffere die Daten und schicke sofort ein kumulatives ACK mit dem Fensteranfang es eine Lücke teilweise oder ganz füllt, puffere die Daten, schiebe Fensteranfang bis zum nächsten erwarteten Byte und schicke sofort ein kumulatives ACK mit dem Fensteranfang Rechnerkommunikation, Transportschicht 119

TCP: Fehlerkontrolle Beschreibung durch Statecharts neues Element: zusammengefaßte Zustände zusammengefaßter Zustand Zustand 1 Zustand 2 grafische Vereinfachung: Zustandsübergänge, die an einem zusammengefaßten Zustand beginnen (enden), gelten für jeden inneren Zustand Zustandsübergänge können auch direkt an inneren Zuständen beginnen (enden) Rechnerkommunikation, Transportschicht 120

TCP: Sender [nextsqn base+w]/ signal refusal to application /base=1; nextsqn=initialsqn [nextsqn<base+w]/ segment[nextsqn]= TCPsegment(nextSQN,data,checksum); IP_send(segment[nextSQN]); if nextsqn=base start_timer; nextsqn+=length(data) TCP_send(data) otherwise/ wait timeout/ IP_send(segment[base]); start_timer IP_rcv(ACK) [base<acknum(ack)<nextsqn]/ base=acknum(ack); if nextsqn=base stop_timer else start_timer Rechnerkommunikation, Transportschicht 121

TCP: Empfänger [no gap remains]/ timeout/ IP_send(ACK[base]); (deliver data until base-1) not all data acked all data acked otherwise/ [SQN(segment)=base]/ base+=length(data); start_timer IP_rcv(segment)/ data=extractdata(segment); buffer data [SQN(segment)>base]/ IP_send(ACK[base]) delayed ACK gap detected IP_rcv(segment)/ data=extractdata(segment); buffer data; base=lowest unrcvd byte; IP_send(ACK[base]); (deliver data until base-1) [gap in buffered data]/ /base=1 otherwise/ Rechnerkommunikation, Transportschicht 122

TCP: Fehlerkontrolle, normaler Ablauf 40-65 66-93 94-125 40 40-65 66-93 94-125 40-65 66-93 94-125 40-65 66 66-93 94 66-93 94-125 126-161 66-93 94-125 126-161 Rechnerkommunikation, Transportschicht 123

TCP: Fehlerkontrolle, Paketverlust 40-65 66-81 82-93 94-40 40-65 66-81 82-93 94-40-65 66-81 82-93 94-40-65 66 40-65 66-81 82-93 94 66-81 82-93 94-82-93 94 82-93 94- Rechnerkommunikation, Transportschicht 124

TCP: Fehlerkontrolle Fast Retransmit es dauert relativ lange, bis ein Paketverlust bemerkt wird und noch länger bei mehreren Paketverlusten ACKs mit der gleichen ACK-Nr. heißen doppelte ACKs sie sind ein schnellerer Hinweis auf ein fehlendes Segment bei Fast Retransmit wird bei 3 doppelten ACKs (also 4 ACKs mit der gleichen ACK-Nr.) eine Sendewiederholung des Segments mit der SQN ausgelöst Anpassung des Statecharts (ein ACK-Zähler dupacks wird benötigt): Rechnerkommunikation, Transportschicht 125

TCP Sender mit Fast Retransmit [nextsqn base+w]/ signal refusal to application /base=1; nextsqn=initialsqn; dupacks=0 otherwise/ wait [nextsqn<base+w]/ segment[nextsqn]= TCPsegment(nextSQN,data,checksum); IP_send(segment[nextSQN]); if nextsqn=base start_timer; nextsqn+=length(data); dupacks=0 TCP_send(data) timeout/ IP_send(segment[base]); start_timer; dupacks=0 [acknum(ack))=base]/ dupacks++; if dupacks=3 IP_send(segment[base]); dupacks=0 IP_rcv(ACK) [acknum(ack))>base]/ base=acknum(ack); if nextsqn=base stop_timer else start_timer dupacks=0 Rechnerkommunikation, Transportschicht 126

TCP Fehlerkontrolle Bemerkungen TCP ist vollduplex: es werden zwei logische Verbindungen realisiert, eine in jede Richtung ACKs reisen Huckepack (Piggybacking): Segmente mit Daten in die eine Richtung werden als ACKs in die andere Richtung benutzt das delayed ACK soll die Anzahl von ACKs reduzieren es gibt eine TCP-Erweiterung Selective Acknowledgements (SACK), bei der zusätzlich im Optionsfeld selektive ACKs gesendet werden Rechnerkommunikation, Transportschicht 127

TCP Fehlerkontrolle Größe des Sequenznummerraums das Sequenznummerfeld ist 32 Bits groß, es gibt also 2 32 Sequenznummern die Bedingung für Schiebefensterprotokolle ist erfüllt: 2 32 >>2 2 16 - Sequenznummer vs. max. Fentergröße Zeiten für den Überlauf der Sequenznummern - bei 10 Mbps: 57 Minuten - bei 1 Gbps: 34 Sekunden für hohe Bitraten also etwas kurz TCP-Erweiterung verwendet Zeitstempel im Options-Feld für weitere Unterscheidung, um Verwechslungen von Segmenten zu vermeiden Rechnerkommunikation, Transportschicht 128

TCP: Verbindungsauf- und -abbau Verbindungsaufbau: Anwendungs-API aktiver Client: Socket clientsocket = new Socket("hostname","port"); passiver Server: Socket connectionsocket = welcomesocket.accept(); veranlasst 3-Wege-Handshake - SYN-Segment: Client sendet Segment mit SYN-Flag=1, zufälliger initialer Client-SQN (client_isn), ohne Daten - SYNACK-Segment: Server sendet Segment mit SYN-Flag=ACK- Flag=1, zufälliger initialer Server-SQN (server_isn), ACK=client_isn+1, ohne Daten; er legt Puffer und Variablen an - ACK-Segment: Client sendet Segment mit ACK-Flag=1; SQN=client_isn+1, ACK=server_isn+1 und ggfs. Daten; er legt Puffer und Variablen an Rechnerkommunikation, Transportschicht 130

TCP: Verbindungsauf- und -abbau 3-Wege-Handshake: Anlegen von Puffern und Variablen Anlegen von Puffern und Variablen Rechnerkommunikation, Transportschicht 131

TCP: Verbindungsauf- und -abbau Sequenznummern bei SYN- und FIN-Segmenten Segmente mit SYN-Flag=1 oder FIN-Flag=1 dürfen keine Daten enthalten, die nächste SQN muss aber um Eins inkrementiert werden, damit diese Segmente explizit bestätigt werden können Verbindungsabbau jede Seite kann Verbindungsabbau durch Segment mit FIN-Flag=1 veranlassen die andere Seite bestätigt mit ACK-Flag=1 beide Seiten müssen ihre Hälfte der Verbindung schließen hat eine Seite geschlossen, sendet sie keine Daten mehr, nimmt aber noch welche an Timed Wait: die Seite, die den Verbindungsabbau veranlasst, wartet zum Schluss noch 2 Segmentlebensdauern, um noch mögliche alte Segmente zu empfangen (und eine neue TCP-Verbindung davor zu schützen) Rechnerkommunikation, Transportschicht 132

TCP: Verbindungsauf- und abbau, Beispiel linke Seite hat nichts mehr zu senden und bricht ab: Timed Wait: 2 Segmentlebensdauern auf mögliche alte Segment warten Verbindung geschlossen letztes ACK: Verbindung geschlossen Rechnerkommunikation, Transportschicht 133

TCP: Verbindungsauf- und -abbau Zustandsmaschine in RFC 793 ist Zustandsmaschine für Verbindungsauf- und -abbau verbesserte Version, enthält alle Möglichkeiten: anything / reset Syn Recvd begin Closed passive open close active open / syn syn / syn+ack Listen send / syn reset syn / syn+ack close / fin close / fin ack Established syn+ack / ack fin / ack close / fin Syn Sent Close Wait close/ timeout/ reset Fin Wait-1 ack / Fin Wait-2 fin / ack Closing fin-ack / ack ack/ fin / ack Time Wait Rechnerkommunikation, Transportschicht 134 Last Ack ack/ timeout after 2 segment lifetimes

TCP: Schätzung der RTT Timeout für Sendewiederholungen der Sender muss einen Timeout wählen ein ACK kann frühestens nach RTT zurückkommen ist der Timeout zu klein, gibt es unnötige Sendewiederholungen ist der Timeout zu groß, kann erst spät auf Fehler reagiert werden der passende Timeout hängt von der Konfiguration ab und ändert sich dynamisch Vorgehen von TCP - Zeitstempel für Segment und ACK, Differenz = Messung der aktuellen RTT - Durchschnitt und Abweichung aus mehreren Messungen bestimmen, daraus Timeout ableiten - Messungen bei Sendewiederholungen nicht verwenden Rechnerkommunikation, Transportschicht 136

TCP: Schätzung der RTT Bestimmung der RTT jede Messung ergibt ein SampleRTT gleitender Durchschnitt (Exponentially Weighted Moving Average): EstimatedRTT = (1-α) x EstimatedRTT + α x SampleRTT bei großem α reagiert Durchschnitt stark auf aktuelle Schwankungen, bei kleinem α gibt es größere Stabilität, aber langsamere Reaktion auf Änderungen, typischer Wert: α = 0,125 mittlere Abweichung wieder als gleitender Durchschnitt, ähnlich zu Standardabweichung DevRTT = (1-β) x DevRTT + β x SampleRTT-EstimatedRTT typisch: β = 0.25 Timeout geschätzte RTT + aus Abweichung abgeleitete Sicherheit: TimeoutInterval = EstimatedRTT + 4 x DevRTT Timeout Backoff: wenn der Timeout ausgelöst wird, wird er jeweils verdoppelt und wird benutzt, bis neues SampleRTT da ist Rechnerkommunikation, Transportschicht 137

TCP: Schätzung der RTT Beispiel für RTT-Schätzung: Rechnerkommunikation, Transportschicht 138

TCP: Fluss- und Überlastkontrolle Flußkontrolle (Flow Control) Mechanismus, mit dem der Empfänger den Sender steuern kann, damit er ihn nicht überlastet aber auch so schnell sendet wie möglich üblicherweise durch Benachrichtigung über Fenstergröße Überlastkontrolle (Congestion Control) Mechanismus, mit dem der Sender davon abgehalten wird, das Netz (Bandbreiten und Puffer) zu überlasten kann durch explizite Signale des Netzes an den Sender erfolgen (z.b. bei ATM) in TCP gibt es klassischerweise keinen solchen expliziten Mechanismus, der Sender leitet sich aus den zurückkommenden ACKs Informationen über den Netzzustand ab und reagiert entsprechend inzwischen gibt es auch Vorschläge für die Erweiterung von TCP und IP zur expliziten Überlastbenachrichtigung: Explicit Congestion Notification (ECN) Rechnerkommunikation, Transportschicht 140

TCP: Flusskontrolle Prinzip der Flußkontrolle die Empfängerseite besitzt einen Puffer, IP fügt neue empfangene Daten ein, die Anwendung liest Daten aus RecWindow Daten von IP frei TCP- Daten im Buffer Anwendungsprozess RecBuffer der jeweils freie Pufferplatz wird der Senderseite mitgeteilt die Senderseite besitzt einen Puffer, in den die Anwendung neue Daten schreibt und mit IP soviel Daten entfernt werden, wie es der Puffer der Empfangsseite zuläßt die Anwendung auf Sendeseite blockiert, wenn der Puffer voll ist dadurch reguliert die Empfängeranwendung die Senderanwendung Rechnerkommunikation, Transportschicht 141

TCP: Flusskontrolle Puffer auf Empfängerseite MaxRcvBuffer AdvertizedWindow LastByteRead NextByteExpected = base LastByteRcvd LastByteRead: das letzte an die Anwendung ausgelieferte Byte NextByteExpected: das nächste erwartete Byte LastByteRcvd: das letzte empfangene Byte MaxRcvBuffer: insgesamt zur Verfügung stehender Pufferplatz AdvertizedWindow = MaxRcvBuffer ((NextByteExpected -1) LastByteRead): freier Pufferplatz, wird dem Sender mitgeteilt Rechnerkommunikation, Transportschicht 142

TCP: Flusskontrolle Puffer auf Senderseite MaxSendBuffer LastByteAcked = base LastByteSent = nextsqn-1 LastByteWritten LastByteAcked: das letzte bestätigte Byte LastByteSent: das letzte gesendete Byte LastByteWritten: das letzte von der Anwendung geschriebene Byte MaxSendBuffer: insgesamt zur Verfügung stehender Pufferplatz EffectiveWindow = AdvertizedWindow - (LastByteSent-LastByteAcked) Sender sendet nur, falls EffectiveWindow > 0 Anwendung schreibt nur, falls LastByteWritten - LastByteAcked MaxSendBuffer Rechnerkommunikation, Transportschicht 143

TCP: Flusskontrolle Bemerkungen zum Ablauf der Flußkontrolle initial wird AdvertizedWindow möglichst groß eingestellt nach AdvertizedWindow = 0 werden periodisch Sondensegmente mit 1 Byte gesendet, sonst kommen evtl. nie ACKs mit wieder größerem AdvertizedWindow zurück Vermeidung des Silly Window Syndroms - Segmente mit wenig Daten sind ineffizient - wenn die Puffer voll sind und kleine Segmente gesendet werden, zirkulieren sie zwischen Sender und Empfänger und bleiben im System - MSS (Maximum Segment Size), Default sind 536 Bytes - wenn der Empfänger ein AdvertizedWindow = 0 bekannt gibt, wartet er danach bis er ein AdvertizedWindow MSS bekannt geben kann Rechnerkommunikation, Transportschicht 144

TCP: Flusskontrolle, Beispiel MaxSendBuffer=MaxRcvBuffer=1400 Bytes MSS = 500 Bytes 1001 2400 2401 1001 2400 2401 (EffectiveWindow = 1400) (AdvertizedWindow = 1400) 1001 1500 1501 2400 2401 (EffectiveWindow = 900) 1001 2000 2001 2400 2401 (EffectiveWindow = 400 < MSS) 1001 1500 1501 2400 2401 1001 2000 2001 2400 2401 Sender blockiert Anwendung liest 500 Bytes 1501 2000 2001 2900 2901 2001 2900 2901 (EffectiveWindow = 900) 2001 2500 2501 2900 2901 (EffectiveWindow = 400) Rechnerkommunikation, Transportschicht 145

TCP: Flusskontrolle Ist das Fenster groß genug? kann es Verwechselungen von Segmenten geben? - das AdvertizedWindow-Feld ist 16 Bits groß, also kann das Fenster 2 16 Bytes groß sein - die Bedingung für Schiebefensterprotokolle ist erfüllt: 2 32 >>2 2 16 kann der Sender den Kanal gefüllt halten? - auf der nächsten Folie ist zu sehen, daß für manche Konstellationen das Bitraten-Verzögerungs-Produkt so groß ist, daß das maximale Fenster dafür nicht ausreicht - als Abhilfe kann im Options-Feld des ersten Segments ein Window- Scale-Faktor F 14 gesetzt werden, die Fenstergröße ergibt sich dann immer aus AdvertizedWindow 2 F - es gilt immer noch 2 32 > 2 2 30 Rechnerkommunikation, Transportschicht 146

TCP: Flusskontrolle Default Window Size Window Scale = 4 bei Werten unter 1 ist das Fenster nicht groß genug, um den Kanal zu füllen Rechnerkommunikation, Transportschicht 147

TCP: Überlastkontrolle Überblick über die Überlastkontrolle der TCP-Sender versucht aus den zurückkommenden ACKs Informationen über die mögliche Senderate zu erhalten hierzu gibt es das CongestionWindow, das zusammen mit der Flußkontrolle zur Ermittlung des tatsächlichen Sendefensters verwendet wird: - MaxWindow = Min(CongestionWindow, AdvertizedWindow) - EffectiveWindow = MaxWindow - (LastByteSent-LastByteAcked) die Bitrate ergibt sich ungefähr aus CongestionWindow/RTT durch Vergrößerung des CongestionWindows vergrößert der Sender die Bitrate und versucht sich an die mögliche Bitrate anzunähern bei einem Verlust (durch 3 doppelte ACKs oder einen Timeout zu erkennen) wird das CongestionWindows und damit die Bitrate wieder verkleinert Rechnerkommunikation, Transportschicht 148

TCP: Überlastkontrolle 3 Mechanismen Slow Start: am Anfang erhöht der Sender das CongestionWindow beginnend mit einer MSS exponentiell bis er durch 3 doppelte ACKs erfährt, dass ein Segment verlorengegangen ist danach erfolgt AIMD (Additive Increase, Multiplicative Decrease): das CongestionWindow wird halbiert und dann linear bis zum nächsten Erhalt von 3 doppelten ACKs erhöht danach wieder AIMD... konservative Reaktion nach Timeout: dann wird Slow Start bis zur Hälfte des aktuellen CongestionWindows und danach AIMD durchgeführt Rechnerkommunikation, Transportschicht 149

TCP: Überlastkontrolle genauer: Slow Start - setze CongestionWindow = MSS - nach Erhalt eines ACKs: CongestionWindow += MSS (hierdurch wird ein exponentielles Ansteigen realisiert) - bis Threshold erreicht ist, dann Additive Increase (am Anfang ist Threshold unendlich) nach 3 doppelten ACKs: - Multiplicative Decrease: Threshold = CongestionWindow/2; CongestionWindow /= 2 - Additive Increase: bei Erhalt eines ACKs CongestionWindow += MSS x (MSS/CongestionWindow) hierdurch wird ein Wachstum um ca. ein MSS pro RTT realisiert z.b.: MSS = 1.460 Bytes, CongestionWindow = 14.600 Bytes, jedes ACK vergrößert um ca. 1/10 MSS, 10 ACKs um ca. 1 MSS nach Timeout - Threshold = CongestionWindow/2; CongestionWindow = MSS Rechnerkommunikation, Transportschicht 150

TCP: Überlastkontrolle Beispiel für Slow Start Sender Empfänger CongestionWindow = 1 MSS CongestionWindow = 2 MSS RTT (delayed ACK wird hier vernachlässigt) CongestionWindow = 4 MSS (ab hier kann ununterbrochen gesendet werden) CongestionWindow = 8 MSS Rechnerkommunikation, Transportschicht 151

TCP: Überlastkontrolle Beispiel für zeitlichen Ablauf: CongestionWindow in MSS 20 15 10 5 0 3 dupacks Threshold = 8 CongestionWindow = 8 3 dupacks Threshold = 9 CongestionWindow = 9 Timeout Threshold = 10 CongestionWindow = 1 Zeit in RTTs Rechnerkommunikation, Transportschicht 152

TCP: Überlastkontrolle ungefährer Durchsatz Annahme: nur AIMD, Vernachlässigung von Slow-Start am Anfang und nach Timeouts CongestionWindow pendelt ungefähr zwischen dem maximalen Wert W und der Hälfte W/2 die Bitrate also zwischen W/RTT und ½ W/RTT im Mittel ergibt sich ¾ W/RTT Rechnerkommunikation, Transportschicht 153

TCP: Fairness der Überlastkontrolle Szenario 2 TCP-Verbindungen teilen sich die Bitrate R eines Kanals Fairness: jede Verbindung sollte R/2 erhalten Vernachlässigung des Slow Starts R gleiche Aufteilung der Bitrate 3 dupacks: Halbierung lineares Wachstum 3 dupacks: Halbierung lineares Wachstum Bitrate von Verbindung 1 R Rechnerkommunikation, Transportschicht 154

TCP: Leistungsanalyse Zeit zum Kopieren eines Objektes mit TCP hängt ab von Objektgröße, Bitrate, Ausbreitungsverzögerung und Verzögerungen durch Protokollmechanismen insbesondere Slow-Start kann sich spürbar auswirken Annahmen - keine Bitfehler und Verluste, keine schwankenden Bitraten und Verzögerungen, ACKs benötigen keine Sendezeit, keine Bearbeitungszeiten, Fenster der Flußkontrolle immer groß genug Notation - S: MSS in Bits - O: Objektgröße in Bits - R: Bitrate - RTT: round trip time - W: Fenstergröße in MSSs Analyse zunächst für feste Fenstergröße, dann für wachsendes Fenster wie bei Slow Start Rechnerkommunikation, Transportschicht 156

TCP: Leistungsanalyse, festes Fenster Festes Fenster, 1. Fall Fenster füllt den Kanal: WS/R > RTT + S/R Verzögerung = 2RTT + O/R initiate TCP connection request object RTT S/R RTT WS/R O/R 1 st ack returns time at client time at server Rechnerkommunikation, Transportschicht 157

TCP: Leistungsanalyse, festes Fenster Festes Fenster, 2. Fall Fenster ist nicht groß genug um den Kanal zu füllen: WS/R < RTT + S/R Verzögerung = 2RTT + O/R + (K-1)[S/R + RTT - WS/R] K gibt die Anzahl von Fenstern an, die das Objekt benötigt: O K = WS initiate TCP connection request object time at client RTT S/R RTT 1 st ack returns time at server WS/R Rechnerkommunikation, Transportschicht 158

TCP: Leistungsanalyse, Fenster wächst wie bei Slow Start wachsendes Fenster wie bei Slow Start: 2RTT für den Verbindungsaufbau O/R für das Senden O/S Segmente K Fenster P Slow-Start-Wartezeiten hier: - O/S = 15 - K = 4 - P = 2 initiate TCP connection request object object delivered RTT first window = S/R second window = 2S/R third window = 4S/R fourth window = 8S/R complete transmission time at client time at server Rechnerkommunikation, Transportschicht 159

TCP: Leistungsanalyse, Fenster wächst wie bei Slow Start Verzögerungszeit Verzögerung = 2 RTT + O/R + Slow-Start-Wartezeiten Slow-Start-Wartezeit im k-ten Fenster - 2 k-1 S/R = Sendezeit im k-ten Fenster - S/R + RTT = Zeit vom Sendebeginn bis zum Erhalt des ACKs - max[s/r + RTT - 2 k-1 S/R, 0] = Wartezeit im k-ten Fenster mit P = Anzahl von Slow-Start-Wartezeiten: Verzögerung = = = O R O R O R + 2RTT + + 2RTT + P k= 1 P k= 1 Wartezeit S R + 2RTT + P[RTT + [ + RTT 2 S ] R k ( 2 k 1 P S ] R S 1) R Rechnerkommunikation, Transportschicht 160

Rechnerkommunikation, Transportschicht 161 TCP: Leistungsanalyse, Fenster wächst wie bei Slow Start Berechnung der Anzahl von Slow-Start-Wartezeiten K = Anzahl der Fenster, die für das Objekt benötigt werden Q = Anzahl von Slow-Start-Wartezeiten bei unendlich großem Objekt dann P = min(q, K-1) Wartezeiten + = + = = + + + = + + + = 1) S O ( log 1)} S O ( log min{k : k } S O 1 2 min{k : O / S} 2 2 2 min{k : O} S 2 S 2 S 2 min{k : 2 2 k 1 k 1 0 1 k 1 0 1 S /R RTT 1 log S /R RTT 1 2 max 0 R S 2 RTT R S max 2 1 k k 1 k k + + = + = + =

TCP: Leistungsanalyse, Fenster wächst wie bei Slow Start Endergebnis: Verzögerung = 2RTT + O R + P RTT + S R ( 2 P S 1) R enthält Produkt von P und RTT, also: wenn RTT groß und/oder viele Slow-Start-Wartezeiten auftreten, kann die Verzögerung spürbar werden Rechnerkommunikation, Transportschicht 162

TCP: Leistungsanalyse, Beispiele Szenario I: S=536 Bytes, RTT=100 ms (intern.), O=100 KB (lang) R O/R Verzögerung 28 Kbps 28.6 s 28.9 s 100 Kbps 8 s 8.4 s 1 Mbps 800 ms 1.5 s 10 Mbps 80 ms 0.98 s Szenario II: S=536 Bytes, RTT=100 ms, O=5 KB (kurz) R O/R Verzögerung 28 Kbps 1.43 s 1.73 s 100 Kbps 0.48 s 0.757 s 1 Mbps 40 ms 0.52 s 10 Mbps 4 ms 0.50 s Szenario III: S=536 Bytes, RTT=1 s (Überlast), O=5 KB R O/R Verzögerung 28 Kbps 1.43 s 5.8 s 100 Kbps 0.48 s 5.2 s 1 Mbps 40 ms 5.0 s 10 Mbps 4 ms 5.0 s Rechnerkommunikation, Transportschicht 163

TCP: Leistungsanalyse, Beispiele S=536 Bytes, O=5 KB, R=1 Mbps, RTT wird verändert: Verzögerung [s] RTT [s] S=536 Bytes, O=5 KB, RTT=100 ms, R wird verändert: von 10 Kbps bis 10 Mbps (logarithmische Skalierung): 2.5 2.0 1.5 1.0 Verzögerung[s] 0.5 100 Kbps 1 Mbps 10 Mbps R Rechnerkommunikation, Transportschicht 164

TCP: Leistungsanalyse, Antwortzeiten bei Web-Seiten Web-Seite mit: 1 Basis-HTML-Seite (O Bits) M Bilder (auch jeweils O Bits) nicht-persistentes HTTP: M+1 sequentielle TCP-Verbindungen Antwortzeit = (M+1)O/R + (M+1)2RTT + Slow-Start-Wartezeiten persistentes HTTP: 2 RTT für Basis-Seite 1 RTT für M Bilder Antwortzeit = (M+1)O/R + 3RTT + Slow-Start-Wartezeiten nicht-persistentes HTTP mit X parallelen Verbindungen Annahme: M/X ist ganze Zahl 1 TCP-Verbindung für Basis-Seite M/X Mengen von parallelen Verbindungen für Bilder Antwortzeit = (M+1)O/R + (M/X+1)2RTT + Slow-Start-Wartezeiten Rechnerkommunikation, Transportschicht 165

TCP: Leistungsanalyse RTT = 100 ms, O = 5 Kbytes, M=10, X=5 S 20 18 16 14 12 10 8 6 4 2 0 28 Kbps 100 Kbps 1 Mbps 10 Mbps non-persistent persistent parallel nonpersistent Für geringe Bitraten wird die Antwortzeit durch die Übertragungszeit dominiert; persistente Verbindungen ergeben nur geringen Vorteil gegenüber parallelen Verbindungen. Rechnerkommunikation, Transportschicht 166

TCP: Leistungsanalyse S 70 60 50 40 30 20 10 RTT =1 s, O = 5 Kbytes, M=10, X=5 0 28 Kbps 100 Kbps 1 Mbps 10 Mbps non-persistent persistent parallel nonpersistent Für große RTTs wird die Antwortzeit durch Slow-Start-Wartezeiten dominiert, persistente Verbindungen ergeben insbesondere für große Bitraten-Verzögerungs-Produkte Vorteile. Rechnerkommunikation, Transportschicht 167