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 cuz 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, 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 cuz 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 cuz 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 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 t he 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, 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 the n.
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.
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.