Congestion & Flow Control

TCP is pretty cool with the different mechanisms that it uses to keep track of all this sequencing and acknowledgements. But there's also another aspect of this that's really cool, and that's congestion and flow control.

This is not meant to be a real in-depth look at congestion and flow control. There's actually a lot to this and a lot of routes that we could go down and explain, but this is a fundamentals course, so we're going to look at the top-layer view of this. We're going to take a look at congestion control and some mechanisms for it, and same thing with flow control, something called windowing. We'll look at these aspects of TCP and how it deals with things like congestion, when buffers get full, and when there are problems that happen on the network and on the machines.

Congestion control

TCP has some great things in it that can help make communication happen very efficiently and make sure that things are streaming at optimized levels. There are times when there's a lot of traffic that can go through, and you can pump that traffic through, and other times when there's congestion on the network, or other problems, where if you were to just shove more traffic down there it would cause worse problems. It's similar to rush hour traffic, where traffic could be flowing pretty well, pretty smoothly, until something happens, or there are extra cars that get added to it, and at some point in time there's a tipping point. Once it hits that tipping point, it's really hard to recover from that, especially if more and more cars are getting onto the freeways. It's the same thing with network traffic: it can flow really well and smoothly, but if it hits a certain point where it's just over-congested, and then there's other stuff being crammed down this pipeline, that can cause problems.

So TCP has a mechanism to help back things off to help control that. In this example, without congestion control, this PC would be sending data to this server, and it would just try to stream as fast as it could, and if this device is too slow, then those packets are going to get stacked up, and it's going to start losing packets, and then there's going to be resending, and that resending is going to cause more traffic and just compound the issue.

There are several things within TCP that can help mitigate this. For one, just acknowledgements. Acknowledgements will help alleviate this problem, because you wouldn't have all of this information getting bogged down if every few segments, or every so many segments, an acknowledgement is sent back. What the acknowledgements do is, as it's sending data over, it will pause and wait for an acknowledgement, and that acknowledgement will say go ahead and send more, or retransmit this data. So acknowledgements really help start shaping this traffic to make sure that we're not getting too much data on any one of these lines.

Flow control and windowing

When we took a look at the TCP header, we also saw this window size. The window size is another mechanism that can help communicate between two devices to say, "Slow down, I need a little less data." Certain devices can send information into this windowing field to let the other side know how much data they're willing to accept. In this example, let's say this device has a certain amount of capacity to process data. If you overwhelm this resource, then it's going to slow down even more, so we don't want to overwhelm these resources. That windowing field has a capability: when it sends an acknowledgement, it will tell the other PC how much this device, this web server, is willing to handle, how much this PC can send during any given time. Then this device will try to fill that up. It will send data to try to maximize that speed, and then every once in a while this machine will send an acknowledgement to acknowledge, yes, I've received this data, and this is the next set of data that I'm willing to accept, that I can handle, that you can send my way.

Now, if it's getting overwhelmed, then those window sizes become pretty small. And if it becomes unresponsive, then possibly this machine will check into this machine and just send, hey, are you still accepting? Are you ready for more information? So this communication can still happen. TCP has that mechanism to allow this communication to happen and allow things to slow down until the time is right to send more data.

Silly window syndrome

Of course, I have to put this in here about silly window syndrome. The silly window syndrome is when this web server continues to broadcast window sizes that are really small, so small that at that point in time it's pretty ridiculous to even try to communicate with it, because those window sizes are so small. I don't know that you need to know too much about that, except that it's kind of a fun name and I thought I'd throw it in there just for fun.

So we talked a little bit about congestion control and how acknowledgements help the flow and stop congestion, just by the pauses that happen for those acknowledgements. We also talked about flow control and how we have some windowing that can happen, so a machine can tell the other side, hey, slow down, this is a little too much information, and it slows the process of sending.