I don't know if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't
know if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't know
if I can hear you, but I don't know if I can hear you, but I don't know if I can hear you, but I don't know.
up and do. I'm just going to ask you to be quiet and positive and we'll just see how we get along.
It's not like the podium.
It's like the stadiums, the lights are going to be loose.
We both are coming.
Okay.
Let's think about the idea of the mechanical scene.
It's when we use a tool with an understanding of how it operates.
So the best of my knowledge is with action is which you don't support
and you're going to have to be quiet and positive.
You're going to have to be quiet and positive.
The focus is that when you can't worry about the canvas in,
and that's what this talks about amazing clarity of machine that will
flow down upon hitting action and running up.
I understand that the machine underneath
is really capable.
It sounds to look like a sequential attributes of maximum abstraction,
And knowledge of where they are structured and that can help you understand why your program
performance was possible and what you might do, like the web, this is a slight oversimplic
touch.
What we are actually looking at here is a bass guitar in the series with a viscous bass, and I'm
going to make a tune with a rosary symphony function, of course what it can be
actually is just a bottle of sweat, but it has acidity and acidity.
Now if you do a few calculations and I hope there's no electric engine as much as we can.
You assume that the reactions we get will, you assume that the reactions or the
acidity are substantially greater than the reactions of the musicians in the series.
Let me do a few calculations based on the impedance.
You know that there is a specific power, you do a few calculations.
You realise very quickly that the power increases what we are actively with the frequency
of the power.
It's double the frequency of the power, it's a quarter.
And this unit, for every single calculation you do, it's quite such a factor.
When you're going, so it takes twice as much power, it takes twice as much energy
when you're going at high speed, then it does more and less.
So, every operation is possible twice as much when you're going at high frequency.
This is why high performance computers of selects from a five gigahertz or so or maybe 10 years
and they've gone down because we're limited by power.
This first sentence is again slightly untrue.
But it's sort of similar.
If you look at the heat transfer coefficient, that's a super-uncooler can do.
It's not madly different from the heat exchanger in the primary cooling circuit of the nuclear air.
The stony shing got true.
Of course, nuclear reactors are shifting more because they're hot, why, usually.
And a modern super-uncooler is a true main space energy.
We can increase power in the structure in the air.
This is particularly true in data centers where, I think every day to center, I'd have a visitor.
There's over extra-regional design budget and power by the percentage.
And we're making sure all of this physical limits.
So, we can't go anywhere else.
And there are very good physical reasons for improving that.
We're doing the other thing to be able to go any faster, least with the spikes of computers that they have in our boxes,
all of them, right there, just something to do.
So, we're going to have to go and buy what we're going to have to do.
Instead of doing things twice as fast, we're going to have to do a lot more functions in power.
And this is something that's been going on for a very long time.
In fact, it's very wide parallel computers that pretend to be sequential machines.
We've got back to the end of the 1960s.
When TJ Watson famously asked an engineer,
why you've got hundreds of people working on the system 360,
but it's still slower than this computer over here,
designed by 12 people working in a shed.
One of the answers was, well, it's because you've got people working obviously.
The guy with 12 people in a shed was Seymour Craig.
And that's what perhaps it is.
But the response of the end was to invent something like the modern superstandard of very wide issues.
This is what the computer of today actually looks like.
And if this one thing I'd like to use to take away through this such thing,
just thinking about what this actually is.
I'm going to talk here.
This is your construction.
On every single block cycle,
10 instructions are deployed in parallel.
Now this is an answer to four computers.
There are similar diagrams for Intel X86 computers.
They're decoders are much, much more complicated,
because Intel has variable length instructions.
On Intel, an instruction is just the stream of bytes.
So, you don't know where it's going to start, you don't know where it's going to end.
Something sometimes you don't know where it's going to end until you actually get what I do.
So, instruction you've got to really tell is very, very much harder.
And the reason Intel is looking for is the life of this,
is because it was my time to do this.
When your architecture was inventing 10 modern 10 years ago,
then you can get it.
So, all of these instructions are decoded.
This is interesting.
Looking at this.
What it's telling you is that although the architecture of the 64-bit architecture
only has 32 or 64-bit,
only has 32 or 64 registers.
The critical, what?
You didn't expect to do that.
Probably it.
The physical machine has nine hundred physical registers.
So, what happens in the front here,
when you start decoding instruction,
there's what's called a rename table,
which basically says, okay,
when the next instruction acts for register 16,
you actually want to register 571.
So, it's a massive look for table.
But, of course, if you're going to execute all of these instructions
in a different order from the art of program,
you've got to do a tremendous amount of work
keeping track of what all the things they're going to be in the cell.
And that's the real one of them here, which keeps...
So, this is what's actually going on.
And you can see here, and you can see here,
there are different instruction blocks
where things that you need to do.
So, this is what the machine actually looks like.
Now, most people, even people do work on compilers,
who are living, tend not to think in terms of this amazing machine
that it really is.
Most compilers, even sophisticated, optimised in five.
I don't know about any of them.
They're actually based around the model
or a straightforward, in-line issue,
register and choose.
But, conditional branches are very, very common.
Some people reckon that there's a branch
every five or six instructions, something like that.
So, in order to use all of that machinery there,
you have to predict where the program is going to go.
This is for speculation, this is for branch production.
But, memory loads are predicted as well, not just branch,
so sometimes a machine will simply say,
okay, I've been reading memory sequentially.
Let's just predict it in the absence of any other language.
What we're actually, we're just going to keep reading things exponentially.
And this works in a lot of the time.
Almost all memory reads a sequentially.
So, it's just thinking about what a clock cycle actually is
from, it's a simply socorration you've got.
It's logical operation, an an and an or an add or something like that,
which is typically limited by some number of gate fields,
which is like 16 or 20 typically.
Memory comes from 11, one catch is a lot more than that.
That's a whole nanosecond.
The multiplication is multiplied, et cetera, et cetera.
So, memory reading data, it takes forever and ever and ever.
And it's a huge, huge latency, et cetera.
So, what you actually want to do is try to arrange your program,
so that it works well on that sort of thing.
But I imagine that most people program me, I don't know,
really be aware of it, but it's not just because the CPU design is trying to find
what I'm trying to do.
They really don't want me to know.
They're trying to put people affect the notion.
But occasionally, as we saw with spectra meltdown bugs,
this very carefully hidden abstraction.
But it also affects how past your program is going to run.
So, these are three things that I've done, which affects it by this.
So, it's about years, not how I've mentioned the earlier,
and no job feature, but reading a step about the conceptual
walks up the job of a stack to find a caller.
And then your search can be stopped.
So, we're looking at various things with the proposal.
And then the end, I'm not really a 16-wide software catch,
entirely software managed, which is local to each track.
So, whenever you look for the value of a stack of value,
rather than walking down the stack, you just look it up in this touch.
Right?
Now, I think you can predict everywhere,
so the fact sure is that, and there's no really anything like,
so I end them into the software catch.
And it turns from being a slow look to the stack,
into something that was literal and believable.
Like, in many cases, there's no hope at all.
Some of this was the thing we have at all, and it's like,
the job is certainly important.
And all from one of them is the combination,
the process of just standing forward,
and walking through the stack, I don't know what that is.
That's just there.
So, it was essentially, it's all the same.
So, this idea, if you've got any look up,
you're going to do it.
So, what you have to do is,
the fields are going back to China.
Just a tiny little thing, which I mean,
the one that's actually in the stock value source type,
is something that's not very simple,
and it's actually in China, because it works in Europe.
But it works in quite a bit faster.
It's particularly good because I spent a lot of time
looking at the actual assembly code output,
that the C2 compiler was producing for access
to the stock value range.
So, it's more cash is highly effective in many other ways.
Okay, so last year, I think to us,
that much of the year, doing this,
there was a problem with the old way
that's interface,
membership access are done.
The old algorithm is very fast,
but it really started parallel in the multi-fledged line.
So, when it was first designed,
this was 20 year old code.
It was perfect.
But now, as soon as the difference
red started asking the same question,
the performance just died,
because you've got a tremendous amount of cash
to hear and strap it going between the various processes.
And it was extremely slow.
So, the algorithm, benchmark,
is at 1.4 meters.
So, what I've said earlier,
you can see that there's no way you can possibly check anything
at 1.4 meters.
That's essentially nothing.
I mean, if you're looking at the speed of light,
it's about that.
So, it was never going to be like that.
So, I thought, at this point, I got interested.
I don't believe that.
What is actually, I don't know.
And then it is this,
to simply, you will always inspect it
with the chance to ask for a speed.
Because, simply, you notice that it always does,
thank you.
So, unless the guarded code uses all of the simply,
you will, which is very likely,
especially in that monster,
so check that's for so much nothing.
And here it is.
Now, you probably cannot see that back,
and there probably can't see it from either.
But this, this first part,
is the check-out.
It's that.
It's, I think, nine instructions.
And you see, these, this is a, this isn't the arm process
that I showed you,
because I can't get a pipeline model for it.
So, you can see that the actual code
that's guarded by the check code
actually begins to cycle
after the check-out code is first-ish.
Now, going to the check-out code
takes until there.
So, it actually takes 30 seconds.
What it doesn't matter,
because the process of executing it's always.
And if the check-out file was,
it will throw away all of this.
And rewind every three.
Throw away all that work at the start again.
So, this is the failure.
I wanted to do more of the same by improving
the other of the use of the invoke interface.
I thought we could do something similar.
I thought we could do a nice hash table look up.
This is a benchmark in open JDK.
And when it runs on the machine,
I was testing it on it.
It runs in less than four nanoseconds.
That is completely impossible.
Clearly, it's doing something.
And what it's actually doing here,
it's predicting memory loads.
So, I changed the benchmark into scrambled
in order to be tested into a different order.
And all of a sudden,
or who this is what happened.
Yeah.
This is actually executing 75 instructions.
So, I changed it.
And all of a sudden,
the performance went right, right down.
So, it was all about production.
So, I'm running out of time,
and this is perhaps a long at all.
But the point is that invoke interface
is legendarily in Java,
supposed to be a slow operation.
It really isn't a slow operation.
If it's well predicted,
if it's poorly predicted,
then not only is the code that does to knock up
like it to be predicted badly,
but all of the target method is going
to be predicted badly too.
And simply scrambling that,
it used the performance so badly
that it was doing six instructions
like down to less than one.
Because it is always executing
the whole net in twice.
Once with the right in operation,
once with the wrong information,
spectacular.
Once again.
So, if you're wanting to take away from this,
invoke interface is nothing to the scale.
Interpaces are a very hard and solid general.
But if you want them to be executed quickly,
then that will only happen if prediction works accurately.
Now, we don't know exactly how prediction really does work.
But it tells you,
keep it simple.
Keep all of your stuff simple.
If you try and do your lab work,
long-term tests and so on,
you're probably going to lose the prediction,
which you need.
And if it's quite what happens,
I like my advantage here,
everything I try was worse
and simple as a pencil search.
Keep it simple, Steven.
Thank you.