- The second
more commonly used
transport protocol available on the Internet is
the
Transport Control Protocol (TCP)
- The TCP protocol
is by far the most popular protocol
used in the Internet
used by
network
application programmers
to write applications (programs) that communicate with one another.
- Designers of TCP:
- TCP was developed by a team led by
Vint Cerf
and
Bob Kahn
Read more on Vinton Cerf (and other Internet pioneers): click here
- TCP was developed by a team led by
Vint Cerf
and
Bob Kahn
- First adoption:
- TCP was adopted in
1982 for use in the Internet.
The 1982version of TCP did not include congestion control
- TCP was adopted in
1982 for use in the Internet.
- First major improvement:
- In 1987, congestion control was added to the TCP protocol.
- The TCP protocol is documented in the Internet standard RFC 793: click here
- TCP provides:
- Multiplexing
(same as UDP)
- Reliable delivery
(TCP uses Go-back-N)
- Flow control
- Congestion control - this service was added later (in 1987) by Van Jacobson and others.
- Multiplexing
(same as UDP)
- Multiplexing in TCP
is realised in the
same way
as UDP:
- User applications select and associate with a
TCP port
- TCP packets contains TCP port numbers to identify packets from different user applications
- User applications select and associate with a
TCP port
- The TCP protocol
also provides
216 (65536)
communication ports
for use to application programs
- NOTE:
- TCP ports and
UDP ports
are different entities
inside one computer
- In total, there are 65536 UDP ports and 65536 TCP ports inside one computer
- TCP ports and
UDP ports
are different entities
inside one computer
- Currently,
TCP
uses the
Go-Back-N
sliding window protocol to ensure reliability.
- Recall that:
- Hop-to-hop reliability
(in the Datalink layer
to your neighboring nodes)
does
not guarantee
end-to-end-reliability
See: click here
- Hop-to-hop reliability
(in the Datalink layer
to your neighboring nodes)
does
not guarantee
end-to-end-reliability
- The
operational environment
in which the TCP layer
operates is
much more hostile
than the one in which
the Datalink layer
operates !!!
- Difference in operational environment between
Transport layer and Datalink layer:
- Multiple hops between source and destination
in TCP
vs.
single hop in datalink layer
- Datalink layer is used between two directly connected machines.
- This different result in a number of
head aches for
the TCP layer
- Out of order packet delivery in TCP
- Packets cannot be re-ordered
when transmitted over a single link
in the datalink layer.
This is because packets travel in the same speed over a physical link/wire, do packets cannot overtake each other
Result:
- The data link layer can interpret out of order reception of packets as a loss of (one or more) previous packet
(E.g., if packets 1 and 4 are received by the data link layer, it can assume that packets 2 and 3 are lost.
-
In contrast,
packets can be
re-ordered during
the transmission
from source to destination
because
different packets can
take different routes
to the destination
(due to routing table recomputation)
So, if the TCP layer receives packets 1 and 4. it CANNOT assume that packets 2 and 3 are lost.
- Packets cannot be re-ordered
when transmitted over a single link
in the datalink layer.
- Varying End-to-end delay
- The sliding window protocol
that ensure correctness
needs to use
timeouts
to recover from failures
The performance of the sliding protocol depends heaviliy on the setting of the timeout value:
- If the time out value
is set too large,
the protocol will
recover from packet losses
(through retransmission) very slowly.
But if the time out value is set too small, the protocol will timeout prematurely and retranmit many packet unnecessaily
- The optimal setting
of the timeout value
depends on the
end-to-end delay
The optimal value for time out is a little bit larger than twice the end-to-end delay
(because it takes approximately twice the end-to-end delay for the ACK to return to the sender)
- If the time out value
is set too large,
the protocol will
recover from packet losses
(through retransmission) very slowly.
- The transmission delay
between two neighboring nodes
will not change
significantly over time
Result:
- Time out values in the Datalink layer can be set very precisely
- In contrast,
the end-to-end delay
used by the TCP layer
is
highly variable
due to queueing delay in switches.
The queueing delay changes from minute to minute !!!
- Result:
- Therefore, TCP must continuously estimate the end-to-end delay, and adjust the time out value to achieve good performance.
- The sliding window protocol
that ensure correctness
needs to use
timeouts
to recover from failures
- Out of order packet delivery in TCP
- Multiple hops between source and destination
in TCP
vs.
single hop in datalink layer
- Flow control
is controlling the rate
(i.e., how fast) that the source
transmits the packets so that
the rate of arrives of packets
does not overwhelm (overflow)
the receiver
Example:
- The receiver can process
maximum
1000 packets per second
- If the sender transmits more than 1000 packets per second for a prolonged period of time, the receiver's buffer will eventually overflow
- The receiver can process
maximum
1000 packets per second
- Congestion is
caused
by offering
more traffic (packets)
than some part of the network can
handle -
i.e., the
demand for bandwidth
in some part of the network
exceeds the capacity
Example 1: a slow link
Notes:
- If the arrival rate to the red output buffer is higher than 1 Mbps for a prolonged period of time, the buffer will overflow
Example 2: conjoint flows
Notes:
- If arrivals from three (3) different inputs are routed to the red output buffer (resulting in an arrival rate of 3 Mbps) for a prolonged period of time, the buffer will also overflow
(You can witness congestion daily on I-85 or I-75 around rush hour. Traffic congestion is similar to network congestion:
cars arrive faster than the highway system can drain them...)
- Solving the congestion problem:
- The answer on "what to do" is easy:
- Reduce the transmission rate....
- Unfortunately, we
do not know
how to do it:
- When should be
begin
to reduce
the transmission rate ?
- And reduce
by how much ???
(If we reduced by too much, it will take much longer than necessary to transmit the data...)
- When should be
begin
to reduce
the transmission rate ?
- The answer on "what to do" is easy:
- The congestion control mechanism
of TCP will be
discussed much later...
- NOTE:
- In contrast, the
data link layer
does not need
congestion control
- The reason
is that the Data Link layer
does not have any
intermediate queue
where packets can accumulate.
- Congestion
can only occur when
packet can
When a packet reaches the neighbor node of the datalink layer, it has arrived at the destination (with respect to the datalink layer) and thus, the packet leaves the system (with respect to the datalink layer)
So packets do not accumulate in the datalink layer - so congestion control neccessary...
- In contrast, the
data link layer
does not need
congestion control
- Congestion control in TCP is still an on-going research topic !!!
- Fact:
- TCP
is a byte oriented protocol.
I.e.:
-
The unit of data
transfered in TCP is
one byte.
- TCP
is a byte oriented protocol.
- In other words:
- Each byte must be acknowledged individually
- Example: sender transmits a
TCP packet contains
byte #1 and
byte #2
It will cause the receiver to send two ACKs:
- Obviously,
every byte
need not be acknowledged
using a
separte ACK message
Recall that Go-back-N uses the cumulative ACK scheme :
- ACK(n) acknowledges all data units upto the sequence number n
Example:
- Previously, the interpretation
of ACK(n) was:
- ACK(n) acknowledges packets with sequence numbers that are ≤ n
TCP's interpretation of ACK(n)
- ACK(n) acknowledges packets with sequence numbers that are < n !!!!
- Sender and receiver parameters:
- Sender buffer is
4000 bytes
- and sender window size
also equal to 4000
- Receiver buffer is
4000 bytes
- and receiver window size
also equal to 4000
- Suppose currently the
send and receive sequence number
is 1001
Graphically:
- Sender buffer is
4000 bytes
- and sender window size
also equal to 4000
- Sender sends a
TCP message that consists of
400 bytes:
- SequenceNumber = 1001
- Message length = 400
Sender's window is now [1401 .. 5000]
- When the destination receives the
400 byte message:
- Receiver window
slides over
by an amount equal to
the length of the message (400)
(It is as if the receiver has received 400 individual packets of one byte
- Receiver window
slides over
by an amount equal to
the length of the message (400)
- The ACK message with
sequence number 1401
will cumulatively acknowledges
outstanding bytes with sequence number
< 1401 (or ≤ 1400)
- When the sender receives the
acknowledgement,
its window
slides to 1401:
- The format of the
TCP header is as follows:
Notes:
- Source port #
and destination port#:
-
used for multiplexing purpose
(just like UDP)
- FLAGS:
indicate a special TCP message
- SYN flag:
synchronize.
SYN is set only when the TCP module wants to establish a connection with another TCP module.
- FIN flag:
finish.
FIN is set only when the TCP layer wants to tear down (terminate) an existing connection with the other end.
(Normal exit).
- RESET flag:
reset (well, what do you expect ?).
Is used by the TCP layer to reset a TCP connection.
It may tear down (terminate) a possible connection with the other end.
(Connection will be closed - abnormal exit)
- PUSH flag:
flush operation
The PUSH bit is set when the user application invoked the push operation that flushes the transmission buffer.
- URG flag::
indicates
urgent data
is sent in the TCP segment.
- ACK flag:
acknowledgement.
The TCP header has two sequence number fields:
- Send sequence number
- Acknowledgement (Receive) sequence number
When this bit is set, the acknowledgement (receive) sequence number is a valid acknowledgement number
Otherwise, the receive sequence number is invalid and must be ignored
- SYN flag:
synchronize.
- SequenceNumber:
send sequence number
of the TCP segment.
Remember that the SequenceNumber indicates a number of bytes (no packet number)
I.e., each data byte sent has a sequence number.
Note: as a general rule:
- Each item
that require reliable transmission
must be identified
by its own sequence number.
Example:
- The
SYN request
used to establish a TCP connection
and the
FIN request
used to tear down a
TCP connection, require
reliable transmission
- Therefore, the SYN request and the FIN request will used one sequence number also !!!
- The
SYN request
used to establish a TCP connection
and the
FIN request
used to tear down a
TCP connection, require
reliable transmission
- Each item
that require reliable transmission
must be identified
by its own sequence number.
- Acknowlegdement Number:
receive sequence number
of the TCP segment.
Recall that:
- In TCP,
ACK(n) acknowledges
all send sequence numbers that are
< n
(Strickly not including n, that is different from the traditional interpretation)
Note: the Acknowlegdement Number is only valid if the ACK flag bit is set.
- In TCP,
ACK(n) acknowledges
all send sequence numbers that are
< n
- Advertised WindowSize:
receive window size
The Adv. window size tells the sending TCP module how many bytes are available in the receiver buffer
(The sender cannot send more data than Adv. window size
More on the Advertised WindowSize field soon...
- CheckSum: checksums the TCP header & message.
- Source port #
and destination port#:
- Definition: TCP Segment
- A TCP message
is also called
TCP data segment
- A TCP data segment
contains zero or more bytes
(E.g., a TCP ACK message may contains zero bytes of data)
NOTE: zero byte data message does not need to be acknowledged
- A TCP message
is also called
TCP data segment
- Using TCP:
- A user application
transmits data
by using a
write operation in
C/C++
(We will be learning how to write network applications in another set of lectures)
- A user application
transmits data
by using a
write operation in
C/C++
- Effect of the write operation:
- The data written by the
write operation
is first stored in a
send buffer
The data is not transmitted immediately to increase efficiency
- The data written by
several write operation
can be transmitted
in a single TCP segment
- Also,
the data written by
a single write operation
can be transmitted
in multiple TCP segments
E.g., when a large amount of data is written with a single write operation
Graphically illustrated:
- The data written by the
write operation
is first stored in a
send buffer
- TCP segment transmission algorithm:
- TCP maintains a
MSS (Max Segment Size) variable.
When the amount of data in the send buffer is ≥ MSS, TCP will transmit a segment of size MSS immediately.
The value of MSS is usually set to the maximum transmission unit (MTU) of the data link layer minus the IP and TCP headers.
(E.g., MTU of Ethernet is 1500 bytes)
- TCP will
transmits a segment
immediately (of size less than MSS) when
the user application issued a
push request.
For example, this feature typically used by a terminal emulation program - such as Telnet - to send user inputs when ENTER is pressed.
(In C/C++, you use the flush() system call)
- Finally, each TCP connection
has a timer (set to
about 3 seconds).
When the timer expires, all data in the send buffer will be transmitted in a TCP segment.
- TCP maintains a
MSS (Max Segment Size) variable.
- The TCP module at the
destination
has a receive buffer.
Arriving data are stored in the received buffer
- The receive operation (read)
can extract any amount of data
from
the TCP receive buffer
with
one single read operation
(upto a certain maximum)
In other words:
- The read pattern is independent from how the data was sent by the sender.