In this course, you will learn to design the computer architecture of complex modern microprocessors.
Introduction to Interconnection Networks
Loading...
來自 Princeton University 的課程
Computer Architecture
266 個評分
從本節課中
Multiprocessor Interconnect 1
This lecture covers the design of interconnects for a multiprocessor.
與講師見面
David WentzlaffAssociate Professor
Electrical Engineering
And I just wanted to say quick note about interconnection networks.
if you guys are, get interested in interconnection networks as we go along,
I highly recommend this book. I have not assigned anything from this
book for this class. But this is Bill Dalley and Brian Towles'
interconnections book. It's quite good.
It's kind of the definitive guide on the subject matter.
Okay. So,
interconnection networks. We,
we talked about buses and we talked about memory protocol about buses.
That's only one way to share information. Now, people may argue that's a intuitive
way to share information because we had the ability to do load and storage from
our processor. But there are other ways to share
information. So, in today's lecture, we are going to
talk about two main pieces of two main topics. One, how do you share information
in, in a different way which commingles the movement of data with a
synchronization primitive. We are going to call that messaging,
[COUGH] which is in contrast to memory or communicating via memory addresses.
We're also going to talk about different ways to connect together processors,
which can either have better performance or better scalability, i.e.,
have more nodes in the system. And, okay, so let's, let's compare and
contrast buses to other forms of network and see why we might want to change.
So, this, this is going back to what we had just talked about.
Let's say, you have two cores on a bus. And let's forget about how you want to
communicate. It could either be via shared memory or
it could be via messaging or it could be via some other protocol,
Ethernet, whatever, whatever you want put here,
which is basically a form of messaging. We have one core and it wants to
communicate with another core. Note, I don't draw any caches here
because there may not be caches, there may be caches.
It's doesn't, it's kind of immaterial here.
If one person wants to talk to another person, they can just yell at the other
person. It's two people so there's, it's pretty
easy to do. We, now, there is some challenges,
we can't both talk at the same time. We might not be able to understand each
other. So, there's some arbitration that needs
to happen. But, in general, that arbitration is
pretty simple. Only two, two cores or entities on this
bus. Okay.
Now we, now we go to more cores. So, we have four people in a room trying
to shout to each other. Well, or four people on a bus trying to
shout to each other. And as, as we just talked about, the
bandwidth can be a challenge here. The arbitration for the bus can be a
challenge. And because we're talking about
interconnection networks, the wire delay and capacitance of the
network can be worse or it can be a challenge here.
So, if we got one core, it needs to drive the shared multidrop bus.
There's a lot of capacitance on this bus, much more so than this case because all
of a sudden, we've, we've, doubled the length of the bus, so the wires are
longer and we've also put more loads on the bus.
So, there's actually more capacitance on this bus.
Okay. Now, we start to think about trying to build a bus that has a lot more cores.
In this case, twelve. And through this core, if you go shot to
that core, there's no pipelines around on this bus or anything.
You go to shout and has to propagate all the way down here and, you know, we're,
we're talking about high rates of communication.
You actually have to wait for the time of flight of light from here to get down to
there. And because we're, if we're using
something, let's say, like a snoopy protocol or a broadcast protocol, because
that's all we have here, we have to wait for and node here to
communicate with every other node. So, we have to wait for the worst case
time for this node to communicate to that node, every clock cycle.
Hm, okay. and as I said there is capacitance, so
it's not quite a, just a transmission line, so it's not just a transmission
line problem here. We also have to worry about [COUGH] the
capacitance in trying to drive all of these different receivers.
And it's a multidirectional bus so we have to have effectively tri-states and
the ability to drive or just receive. Well, all of a sudden, we have twelve
people and actually, we have twelve people in this room.
So, let's all try to pick a number between one and ten and shout it real
fast on the count of three. One, two, three,
five. Okay.
I could, I, I do, I shouted five, I don't know what everyone else said.
So, [LAUGH] that's does anyone, could everyone hear everyone else's?
Does everyone know exactly what all other ten people said at the same time,
or twelve people said at the same time? You heard your nearest neighbor.
Okay, but did you know, do you know what Yankey said?
Yeah. Okay. So,
this is, this is the challenge. And if we need to guarantee that only one
person can yell on the bus at a time, we need some arbitration.
But the arbitration logic is slower now because we have lots of people
communicating so we have to run a wire from this node down to this node and
then, we had to come back in the arbitraration, logical, say, over here
that needs to make some decision. And the decision is slower because as
more layers of logic, more combination of logic, we will say, to make arbitration
decision. Hm, okay. Now, if we go to a thousand
processors or a a thousand cores on a bus,
you know, we, we could even have twelve people in the room shout at the same
time. You can have a thousand people in the
room shout at the same time, and physically be distanced to the wiring
between this thousand different nodes is going to decrease the speed of the bus
significantly. So, it's some, something to think about.
So, this, this motivates us to take the same twelve course and think about some
other ways to connect them. Now, what I'm going to show here is a,
what's known as a switched interconnect or sometimes known as a point-to-point
link solution. Now, point-to-point does not mean that
this core can communicate directly with every other core.
That has, that has a different name, we'll talk about that later today.
Instead, point-to-point just means each link,
only has one sender and one receiver. And then.
you use switches along the way to make decisions and to route.
So, if we look at this, we can actually have multiple nearest neighbor
communication happening. So, all of a sudden, by adding this
switching, we can both have connectivity between all the different nodes, but we
can also have sort of subconversations happening.
But this still allows for this processor here to go communicate with the one
that's at the farthest extent. And we need to decide how to do that.
Whether it communicates sort of this way or this way or that way or some other
squiggly line. [COUGH] We can also take the same
point-to-point switch interconnect network.
And like a bus, which we can increase the width of the bus,
which does not help us with the occupancy on the bus,
we can add more networks or we can affectively add multiple concurrent,
switching interconnection networks or we can increase the bandwidth on these
buses. So, it's similar sorts of ideas there and
similar sorts of bandwidth tricks you can do to increase bandwidth on buses.
You can play on there, switch interconnection always.
Okay. So, this is just a very broad overview. And now, we're getting into
some, some more specific ideas.
