Clang

The feature should write itself.

So this is using some fancy GCC and Clang optimization.

It's using one of the built-in, built-in unreachable, which tell the compiler that some chunk of coding is unreachable and it triggers some optimization.

And apparently the author, this is Mas, that did this, he managed to use it in a way that makes the compiler optimize out the API access indirection function, if I understand correctly.

If we own those things, maybe it's valuable to make them better.

But how do you do that when there's 50,000 call sites or 100,000 edits that need to be made to change that API? And so luckily I was friends and org chart cousins eventually with the compiler team, especially Clang LLVM people.

And so they started doing stuff in the AST transformation sort of space.

AST.

There's a pull request.

This one is not super new, is it? Like to add the Clang trade safety analysis.

And it's one of those checks where

for

introducing it, we need to fix our code first, right? And so that's why it's been around for this long.

I think it's been fixed at that time.

So when this was introduced, we didn't even have, this applies for Clang, right? So when this started, we didn't even have it in CI.

And I remember, I think Anna's thrown it at me because he knows we use Clang downstream and he was like, hey, this may break you.

I think the sort of the initial result approach is problematic because you're optimizing for a benchmark, and you get something that's good but not real.

For instance, we support PGO, which is, um, the Clang, uh, approach for doing a benchmark run.

But w- it's off by default, and we never use it in our benchmarks because I think of it as kind of like cheating because you're running sort of a warm-up that isn't really how the app will, uh, necessarily represent in, in practice.

So we have it there because there are some special cases that might actually benefit from it.

The compiler is already very good.

Modern GCC and Clang do a lot of work that used to require hand-tuning.

If you write reasonable code and compile it at 02, you're already close to what the hardware can do for most workloads.

The gap between a generic build and a tuned build is small because the generic build isn't leaving much on the table.

It sounds like it.

GCC with PGO came out 94% slower than a plain 02 build.

Clang with PGO, 8.7% slower, and the reason is interesting.

The optimizer used the profile to speculatively devirtualize the calls, replacing indirect calls, which the CPU predicts well, with type guards that mispredict.

And a bunch of stuff in the back end pipeline will just stop working.

So maybe Google, I know they have some patches on Clang.

So I don't know if it's because of that or it's because they do something smarter.

I'm really curious about this.

They're already useful.

And so I'm like, I think the thing that the Rust Foundation could do to help them is basically provide support and social connections when they get blocked by things.

A good example of something like that was there was a longstanding bug for 128-bit integer API where Clang and GCC weren't agreeing.

And so because, well, this is not really Clang, it's LLVM.

Yeah, yeah

... everything with your GCC and your Clang.

Exactly.

Give food to your code developer in the ground.

"Hey, how, how can we make this work in 3.14?" And, and that was the idea.

You can just literally take the, the profiling package, right, and, and just copy that over, but it's not that simple.

So there are, there are some changes in, in CPython, in, in internal CPython, uh, um, structures in Clang.

And so you do get...