Dynamic Routing Protocols

What Dynamic Routing Protocols Are

This is just an introduction to dynamic routing protocols, not an in-depth look, but a brief overview. First we'll look at dynamic routing protocols and what they are, then at distance vector versus link state routing protocols. We'll then take a little more in-depth look at distance vector and a little more in-depth look at link state, to compare the difference between the two.

Dynamic routing protocols are what routers use so they can discover remote networks. With this router right here, we know that this network is a directly connected network. When you bring this interface up with an IP address and a subnet mask, then this network shows up in the routing table as a directly connected network. But how does it learn of this remote network? It's going to do that either by entering a static IP address, where you manually enter it into the routing table, or it's going to learn it from other devices. Other devices are going to share information so that each one knows about each of the networks that exist out there, so that communication can happen throughout all of these networks.

Distance Vector Versus Link State

Let's look at two common dynamic routing protocols: one would be distance vector and one would be link state. Distance vector is made for much simpler setups and simpler designs, versus link state, which is what you use if you want some additional features. Distance vector is more simplistic in its setup; link state is more complex. But once you get it set up, link state has a lot more options to it than distance vector. Distance vector is commonly used for more simplistic or smaller networks, versus link state, which is usually more for larger networks or more complex networks.

One of the things we look at is path calculation, and what it takes to calculate the path from one destination to another. If a router receives a piece of information, how does it determine what the next hop is? Distance vector uses hop count. The information that gets passed around just increments the hop count. So if it has a few routes it could take to get to a remote network, and one of them has two hops -- two other routers to get to that location -- versus a path that has three hops, three different routers to get to that location, it's going to choose the two-hop path, even if the bandwidth is significantly less on that. That's where we say distance vector is great if you have something more simplistic, but if you have different bandwidths and different needs, more complex features, then distance vector is not going to be the right one for you.

Link state uses what's called shortest path first, or shortest path metric, which calculates a lot of different factors on what is going to be the best route, to include bandwidth. Bandwidth is a huge one that plays a factor into which route I'm going to go. That's shortest path metric with link state.

There is some other information here we're not going to get into at all, but some examples of this: RIP or IGRP would be examples of distance vector, and OSPF and IS-IS would be an example of link state protocols. Those are some examples of different protocols that fall within distance vector and link state. One other thing to note is the algorithm here, Bellman-Ford versus -- I'm not even going to try to pronounce that one. The algorithm is just the process by which it chooses the best route to any kind of remote location, a remote network.

How Distance Vector Calculates Hop Count

When you actually look into distance vector, how is it calculating hop count? We know that this network right here is a directly connected network, and as soon as you bring up that interface with an IP address and subnet mask assigned to that IP address, that is going to go into its routing table. This router right here will also have this directly connected network within its routing table as well. And then these other devices still have networks that are associated with them. So here are networks in between each one of these, and those will all go into these routing tables. That information is found in the routing table.

Now let's say we turn on something like RIP on these routers. This information uses the RIP protocol to pass the information back and forth. What that looks like is that this routing table gets dispersed in both directions. Then these devices, provided that they have the same dynamic routing protocol turned on, will listen to that, take that information in, and put it into their routing table. But when they put it into the routing table, they'll increase the hop count by one. Then they will take their tables and disperse them in each direction as well.

So this information then makes it to this router right here, and the information to this remote network makes it into this routing table. Then this router is going to send information out, and that information is going to get into here, and then it will make it into this routing table right here. So then this remote network is inside of this routing table right here. This information gets passed back and forth, and all of this information gets put into these routing tables. That's distance vector. But every time it gets passed from one location to the next, it increments that hop count.

So this router right here understands it's one hop this direction to get to this network. It's two hops in this direction, and it's three hops in this direction. Since this is a distance vector dynamic routing protocol, it's going to choose the shortest path, which is going to be the least amount of hop counts. So it's going to be the straight line over to it. Even if this is the smaller bandwidth and has a lot less bandwidth, it will choose this route over the other routes.

Convergence

Now we have something called convergence. Convergence is the point when all of these routers get the full view of all of the networks -- then we've reached convergence. There's also a convergence speed, the speed at which all of this communication happens.

Here's what I mean by this. Let's say this router right here sends information to this router and this router. It sends it out and that information for those routes gets put into the routing table. This router still doesn't understand about this network right here. So now this router right here sends out information in this direction and this direction, and this network is learned into this router. Then this router will give an update out of both directions, so now that route gets put into here. Now this router knows and understands about this network, but still doesn't know about this network right here. Then this router sends out information in both directions. This router sends out information in both directions. This router sends out information in both directions.

And then what happens is that finally the route to this network gets passed on to this router, and this router understands that this network can be found in this direction. So what we have is a learning process where all of these routers start communicating out, and as soon as they get an update they communicate out again. And as soon as they get an update, they communicate out again. That has to happen until everybody understands all of the networks and there are no more updates to be had. At that point in time, we've reached convergence.

Convergence is the point in time when all routers on this particular segment here, all of these routers operating in RIP, understand where all of the networks are. Now we have convergence. The speed at which that happens is called the convergence speed -- the speed at which we converge, the network converges, and all of the routers get the full picture of how to get to each one of these networks. Some examples of this would be RIP, RIP version 2, IGRP, and EIGRP -- these would all be examples of distance vector.

Link State

Link state has the same thing, where all of the networks need to be converged, or the routers need to converge into one solid form, one solid map. That's actually one difference about link state. With distance vector, a router just understands what the next best hop is, where it needs to send information, and it's very simplistic in the way it just transfers -- the whole routing table gets sent out in each direction, and that's how it reaches convergence.

Link state is a little different. When a route gets added, it will form some information about that network that's been added, and then it will send out information about that network in each direction. So this information, rather than the whole routing table, gets sent out, and the repercussion of that is that all the routers understand where all the connections are within this instance of the routing protocol. The information is passed all around, and each router can create essentially an internal map of how all the connections are connected. So it has a much more global view of how networks are, and if a link goes down, what other directions it can send information as a backup way of doing it. RIP and distance vector have some capability of doing that also, but link state is much more able to adapt and adjust because it has the whole concept and the whole map of how the networks are arranged.

Another difference with this too is that as a link goes down -- let's say this remote network to all these routers that are out here goes down -- then rather than sending out the whole routing table to discover what the update is, it will just send out updates of what specific link went down. So once a network is converged -- and convergence can happen possibly a little bit longer with link state -- but once it is converged, then all it needs to do is send out little updates to update everybody on any changes that happen to this network. That's link state. There are a lot more little communications that happen for managing this type of network and giving little updates, rather than these big communications of transferring the whole routing table from one router to the next. It adds a lot of different features and allows for a lot of positive features, great features, that can be added to link state over a distance vector routing protocol.

Comparing the Protocols

Here's another breakdown of it. We talked about convergence speed. Here are some different aspects: how these different routing protocols converge and how fast they can converge, how scalable each one of these routing protocols is, and the resource usage that each one of these routing protocols will take up. Resource would mean how much compute power a router will need, how much memory a router will need, and how to implement and maintain it.

Distance vector, once again, for the most part we see that it's simple to implement and it takes up lower usage from a resource standpoint, although convergence is slower and scalability -- it's not really scalable. Versus link state, where we have much faster convergence, but it's much more complex in implementing, and resource usage can be higher.

But we also see this magical little spot right here: EIGRP. RIP version 1 and RIP version 2 would be the most basic implementations. IGRP gives you a few more features. EIGRP is Cisco's Enhanced IGRP, and it takes a little bit from each of the worlds. It's still not the perfect protocol, but it combines some of the advantages of distance vector with some of the advantages of link state, and we find a little bit of a happy medium ground with EIGRP.