So this is where some people got the idea that maybe there, maybe there is a better
way. And I wanted to point out that there's
only, this is only the tip of the iceberg of what we'll call better ways of having
better instruction sequences or better encoding standards between compilers and
the hardware. This is actually a open, sort of, research
topic now. Very long instruction word processors or
VLIW for short. Is one take on it.
There's been a fair amount of work done after this, which we're not going to talk
about in this class. Sort of in the last five to ten years,
that has looked at this in a little bit more detail.
Especially given sort of, Multi-cores, and can you schedule across
multiple cores, Or there's a project. There was a project
out of the University of Texas at Austin, which tried to schedule across, something
that sort of looked like cores. But wasn't quite cores.
That was sort of, we'll call a super VLIW but had some dynamic aspects and some
static aspects. But for right now let's talk about very
long instruction word processors. Okay where is, where does the name come
from? Let's start there.
Well, these were things that were actually originally called long instruction word
processors. The name kind of fell out of favor.
At, at one point people made a differentiation between long instruction
word processors and very long instruction word processors.
And it was kind of on how many instructions were packed together.
The, the differentiation has largely sort of fallen out of favor now, and people
mostly call all of these things VLIWs or very long instruction words, cuz it's,
it's harder to say what is long, what is very.
It's kind of just a extra term. It's also, it's kind of like people
talking about Large Scale Integration versus Very Large Scale Integration versus
Ultra Large Scale Integration or you know, people just sort of keep tacking on extra
letters in the front. But let's talk about VLIW instruction
sequences, And, and what is, what does one of these
things look like? Well, VLIW instruction.
Will actually have multiple, operations within one bundle.
So typically, this is you call a bundle or an instruction, which with multiple
operations inside of it. So, in this example here.
We have six operations that can be executed in this one instruction, or in
this one bundle. And, typically, there in a sort of fixed
format. So let's say we have, you can only, can
execute two integer operations, two memory operations, and two floating point
operations, per cycle, and that's what you're allowed to encode.