Well, we still have a couple of problems to address that fast switching didn't
quite
solve for us.
The first of which is the cache itself.
As great as the cache is, and speeding things up, and avoiding the use of the
CPU, it still
relies on process switching, and it still has to be repopulated pretty
regularly.
The other problem is we still have to perform Layer 2 Lookups.
Once I know where I'm sending the packet, I still have to perform an ARP lookup
, and
that just adds to the slowness of the whole thing. WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
that just adds to the slowness of the whole thing.
And so what we really want to do is we want to create a solution that is
proactive.
It doesn't rely on reactively performing process switching that doesn't react
ively
rely on performing Layer 2 Lookups, and this is going to lead us to Cisco's
famous solution
known as Cef.
So what exactly is Cisco Express forwarding?
We talk about it a lot, especially just talking about Cef as a concept when we WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
We talk about it a lot, especially just talking about Cef as a concept when we
're studying
Cisco architecture and Cisco devices, and when we first start studying for the
CCNA.
But what exactly is it?
Well, again, it is meant to be that proactive element that allows us to achieve
an ultimate
form of speed.
It's going to be as fast as possible when we perform our switching.
Now again, it is its own process.
It's not fast switching.
It's just going to perform switching very, very fast. WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
It's just going to perform switching very, very fast.
There are two key components to Cef.
The first component is known as the forwarding information base or the FIB.
This should sound a little bit familiar, sort of sounds a little bit like the
routing information
base or the rib, but now we're talking about the FIB for Cef.
And the second component is going to be known as the adjacency table. WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
And the second component is going to be known as the adjacency table.
And we don't really have an abbreviation for this.
It's kind of nice as much as we love our three letter acronyms.
We do just have to refer to this as the adjacency table.
So what are these two tables?
Well, the forwarding information base or again, the FIB, this is going to be a
copy of the
rib, but it's going to be highly optimized.
It's going to be, first of all, stored in T-cam. WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
It's going to be, first of all, stored in T-cam.
And secondly, it's going to use a completely different architecture for our
lookups.
So remember, T-cam allows for parallel lookups.
It allows for very fast lookups.
But also architecturally, we're not going to look at every single entry and
sequence like
we do with the rib.
We're instead going to perform much faster lookups using different methods.
So we can think of it as just a faster rib if we want to.
And that's pretty good understanding of the FIB.
But to delve into a little bit more details, we do see why this actually is WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
But to delve into a little bit more details, we do see why this actually is
faster.
Now with the adjacency table, we're going to use this to solve this other
problem with
layer two lookups.
And so we're going to store layer two addressing information right here as part
of the Cef process.
This allows me to be proactive on the layer two front and even to have the
concept of
these prepackaged headers that we're going to use. WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
these prepackaged headers that we're going to use.
Now again, we're talking about layer two headers in here, not prepackaged layer
three
headers, because again, if I'm sending a, I could have a bunch of different
packets going
a bunch of different directions, if they all go through the same next hop over
here,
every single one of these layer two headers is going to be identical because I
have the
same source MAC address, I have the same destination MAC address.
And for the most part, that's it.
When it comes to my ethernet headers, we have to worry about the ether type and
maybe a WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
maybe a
VLAN tag if we're trunking.
But again, all of that will be the same.
So I can use the same prepackaged header as long as I'm going to the same next
hop.
So now when a packet comes in, I don't even have to check the rib.
The rib is completely out of the picture.
Instead, I'm simply going to go through the Cef process, which involves the fib
, and I'll
go and abbreviate this as the AT for adjacency table here, just for the sake of
fitting it. WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
fitting it.
But we're going to go through the Cef process, which again, this has already
been populated.
I don't have to wait for the first packet to get processed switched, and then I
can populate
the fib.
That's not how it works.
This is preemptively populated based on what's currently in the rib and what's
currently
in the arpe tables.
And if there's changes, we get preemptively updated here in the Cef process.
And so this is as fast as it can possibly get switched over to the outgoing WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
And so this is as fast as it can possibly get switched over to the outgoing
interface,
and we have our new layer two header as well.
So when we think about things from a diagram, before we're to diagram this out,
keep in
mind, we've said that we've got these routing protocol tables up here.
So this would be our OSPF database and our ERGRP topology table.
And then these are going to be feeding the rib, routing information base. WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
And then these are going to be feeding the rib, routing information base.
And then we also, by the way, are going to have our cam tables and our ARP
tables over
here.
And as I've said, by the way, this is also neighbor discovery for IPv6.
We don't use ARP with IPv6.
We instead use ND, neighbor discovery.
But either way, we've got these separate tables.
And so now we have the Cef process where again, I'm going to use the rib to
create the fib
proactively.
And I'm going to bring in my layer two information in here for the adjacency WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
And I'm going to bring in my layer two information in here for the adjacency
table.
And so now my packet is again going through this process down here, referencing
these
tables in hardware.
The CPU is not involved.
The rib is not directly involved.
None of these tables are directly involved because all of the information is
here in a
very fast process and a very fast method for performing lookups.