Okay.
This brings us to our next optimization,
which is the amount of [inaudible]
optimizations and this is one that
actually is no longer talked about in your
textbook.
The old versions of your textbook did talk
about this optimization.
I, I think it's still an important,
interesting optimization to think about
and this is something called a victim
cache.
The victim cache, let's take a look at the
picture first. Here,
Cpu, L1 cache, L2 cache,
It's a multilevel cache.
But now.,
If you're missing your L1, you put another
little spot check.
We put something we call a victim cache
and a victim cache is a fully associative
cache but it's usually very small.
So, let's say, one, two, three, four
entries, something like that.
Seems very small cache structure here, but
it's fully associative.
But what's nice about this is sometimes in
programs you have a problem where, I don't
know, let's say, you have a two-way set
associative L1, which you have three
things that want to be in that one
location that has one index to cache.
This keep fighting and knocking each other
out over and over and over again.
Just actually one extra fully associative
entry would solve this.
And then you have the edit here in the way
zero, way, way one, and now it's victim
cache.
So this is actually the, the first
processor that showed up in was an HP
PA-risc processor.
Probably HP 7,000 per [inaudible] 7,000
series processor.
But, you can actually have this, this
little extra cache here.
A couple extra little things you need to,
to think about though, is, whether you
check this cache in series or in parallel
with the L1.
If you're checking in parallel it's going
to hurt your hit time.
We've checked with the series, checked
this first, then checked this, and then
checked the L2.
You know, checking these together so we'd
have a worst hit time, like we need your
L1 to sort of pass it along the way it
was, so you don't have to put multiplexer
and, after your L1 checked.
It's a trade off. People, well,
Well, checking both in parallel and in
serial.
Let's look at the mechanics of how this
works.
So on a this inner L1 we're we generate
the victim,
Gets your transition the victim to here
and then we bring in the new data from
here into the L1.
Unless, the data is in the victim cache
already and then all we do is basically
swap the two,
Take the lines in the victim and lines in
the data, and swa, but you usually have
sort of separate data paths in that.
You can have going on simultaneously.
So you could, after one big, we are one at
the other, and vice versa.
If you missing the victim cache, missing
the L1, interesting question comes up here
with your data that's in the victim cache.
What happens to that?
We put a victim in the victim cache.
Do we need to do something with that
victim first?question
Mark here.
Hm,,
Unclear.
It really depends on design.
If the design is such that when we,, when
we generate victim from the L1, we both
put it in the victim cache and we flush it
down to our L2.
Then, when we have to, let's say,
victimize from the victim cache, the
victim cache would say only its two
entries, and we need to put a new victim
in the victim cache. We can just throw on
to the ground.
We don't actually need to deal with that
victim because the data is [inaudible] If
not, we'd actually have to take the upper
victim cache that's possibly dirty and go
over it out into the L2.
But in reality what this is trying to do
is it's trying to reduce our
conflictnesses, by gaining us a pseudo
higher associate cache with just a very
small second.
It's interesting to look sort of a
[inaudible] and people that built on this,
This victim cache, a very small victim
cache, can go a long way.
Because there's a lots of times in the
program, there may be that one value, that
one address which is what highly intended
in your cache, or this L1 line of cache.
But everything else in the cache is a sort
of [inaudible] will say.
And this can really help you with the
[inaudible].
Okay, so going, going back to our victim
cache here,
If we look at the sorta our victim cache
just by itself shouldn't be L1.
This kind of looks like a multiple cache.
The answer is going to be the same as what
we had for a multiple cache.
If you look at it just through the L1,
it's going to make the Miss Penalty go
down as we [inaudible] If you look at the
L1 with the victim cache, both the Miss
Penalty will be more than we had to go out
to the next level cache.