Okay, so today we're gonna pick up where
we left off and continue talking about out of order processors?
And things are gonna start to get a little complicated, but that's good.
We don't want to build, well, we want to try to build simple things, but we also
want to build high performance things, so. Let's start talking about some more
complex, out of order processors than we talked, talked about last time.
So last time we talked about In order, in order, in order processors, and we
introduced a scoreboard, and then we started to talk some about in order, in
order, where the front of the machine is in order and the issue is in order while
the write back and the commit are out of order.
It also uses scoreboard, and today we're going to start talking about things that
even have higher performance. And this is sort of, roughly put in sort
of order of performance and sort of what people build if they actually want high
performance in their computer systems. And we're gonna start talking about in
order on the front end, out of order in the back end, and we're gonna have to
introduce things like re-order buffer, and a store buffer.
Then we're gonna talk about a machine which has in order front end and all the
back stages are out, out of order. Which may not make a whole lot of sense,
because out of order commit starts to look a little odd.
Likewise that's the, the case for this processor.
And, and, so why does out of order commit look a little odd?
Well, when you start to have out of order commits it's very possible that you could
if want to have a precise exceptions point.
It, depending on how you sort of implement that processor, and depending on where you
put the commit points. If you put the commit points let's say at
the end of the pipe it's very possible you'll commit results to your register
file, or your architecture register file before you know that those results are
good. So you've basically just executed
instructions and committed information that's not correct in program work.
And we'll show you some of that today. Then finally we're gonna talk about sort
of a, the highest performance thing here, which is a, in order, fetch.
Out of order issue, out of order execute, and right back, and then finally an in
order commit. So this, you can have precise exceptions,
have a commit point at the end of the pipe.
And for this we need to introduce an issue queue, which is where the instructions
sort of live for a while as they're getting ready to go issue, and this allows
us to do out of order issue. Just to recall back our motivating
examples. Example, we're gonna be using this example
throughout today's lecture again. Two different instruction code sequences
not dependent on each other. You should be able to execute these things
in parallel if you had enough parallels on your machine.
And we talked about this already. So I'm gonna skip past the, in order, in
order, in order machine. And get to, in order, in order, front end
an issue, and out of order right back in