Writing Rust code that's fast by asking agents to make the code faster

Writing Rust code that's fast by asking agents to make the code faster minimaxir.com

116 points•mooreds•9 days ago•65 comments•

#code #faster #rust #writing #asking #agents #rust code #writing rust

65 comments

I have done a fair amount of low level performance optimization with Opus 5 and its reasoning is still very poor. Like why is CRC so slow and going through loops until I ask it if is using hardware instructions and it tells me it is using its own hand coded implementation poor. Reasoning about l1/l2/l3 cache hit ratios and their implications basically throwing darts at the wall, in the wrong room. If you give it a benchmark feedback loop then it might get there eventually but still massive alpha for low level systems engineers who instinctively know how this stuff works and can now automate 99% of the grind.

bee_rider8 days ago

> Reasoning about l1/l2/l3 cache hit ratios and their implications basically throwing darts at the wall, in the wrong room. If you give it a benchmark feedback loop then it might get there eventually but still massive alpha for low level systems engineers who instinctively know how this stuff works and can now automate 99% of the grind.

I suspect a lot of the training set for this sort of thing is people online speculating about cache performance incorrectly.

louthy8 days ago

Speaking as somebody who is a performance geek, my knowledge came from relentless experimenting over the years (starting in the 8 bit era). Beyond the basics, I haven’t seen much on high-performance engineering online. To learn, you need to do the hard yards and I think performance tweaking becomes almost instinctive rather than something driven by a hard set of rules.

At a low enough level, every performance tweak becomes unique and bespoke.

Of course, you could find people online talking about how to write high-performance code, but beyond a few basic techniques, their advice may not work for you — nobody can write a generalist article about performance engineering that will definitely solve the problem you have right now.

Arguably, there are fewer patterns for an LLM to infer as highly optimised code tends to become more and more opaque in the search for a nanosecond here or there.

devin8 days ago

I would think it's that the kinds of places which value this kind of knowledge often have major disincentive to share it. I'm thinking of HFT firms as one example.

physicsguy8 days ago

I ran into the exact same wall when doing some SIMD + OpenMP optimisations.

Me: "Parallelise this loop without changing the results."

AI: "I can't do that, because of floating point accumulation."

Me: "So spin out a temporary fixed-length array, accumulate into that thread-locally, and then do an ordered summation of that at the end."

AI: "Oh, you're right!"

It's a fantastic tool for automating the implementation grind, but you still have to hand-feed it the strategy. I guess it will get there at some point.

la_mezcla3 days ago

>> I guess it will get there at some point.

Each tool in any domain "will get there at some point"

lordnacho9 days ago

Can you give it the valgrind suite to loop over? I have yet to try that with AI, but maybe the cachegrind tool is enough to help it.

RomanKornev7 days ago

A new meta is emerging of having high taste + infinite compute with little domain expertise. One recent example is Jarred Sumner taking a crack at the Riemann Hypothesis

> Throughout this process, Jarred's input was mostly limited to sending Claude messages of encouragement (mostly variants of “keep going” or “believe in yourself”).

How much experience can you replace with infinite compute remains to be seen I guess.

https://news.ycombinator.com/item?id=49247070

kccqzy8 days ago

I see the same thing, except I was working on high level performance reasoning. Whenever a piece of code has multiple steps that require multiple algorithms to work, AI almost always fails to guess which step is the slowest and what causes that step to be slow. Even Fable makes wrong guesses. You definitely need to give them a benchmark feedback loop.

lordnacho9 days ago

I've been having great results with this kind of thing. I find that really just need a sensible framework within which the optimization can take place. Essentially just providing the measurement harness, and some sort of motivation for what I'm doing.

The great thing about LLM is that it seems to have the checklist for everything. If I rattle off a few things like "don't allocate on the hot path" and "remember to pin the cores" it will come up with a few items of its own that I might have forgotten.

Eventually, it will have gone through the whole list with me, while having documented all the measurements along the way.

But it's still guided by experience. If I see unusual numbers, I might say "hey did you forget to compile it in release mode?" and it will apologize and fix that. If I don't, it may just continue exploring without realising everything is wrong.

hombre_fatal9 days ago

If it can be measured, then LLMs can optimize it.

Once I had repo commands that could dump `sample` results and a cpu profiler/trace and then a benchmark tool that let me A/A + ABBA/BAAB-test the current modified git workspace against HEAD or any commit, the LLMs could just do their thing.

And that's how my homemade terminal uses much less memory than ghostty/kitty/iterm yet has more throughput.

AI is going to increasingly unmask people and companies who don't care about correct and performant software now that it's become so trivial to guarantee both. It used to at least be expensive and time-consuming and expertise-demanding to do those things.

dasil0039 days ago

Agree it's amazing how much low-hanging performance fruit AI can trivially find. On the other hand though, once you get through the obvious no-brainer stuff, there's a lot of non-trivial tradeoffs in performance and I think that still demands a good amount of expertise to guide the AI in the right direction. Obviously AI will continue working it's way up the value chain, but I think there's a glass ceiling for AI where the right macro tradeoffs and perspectives on how software should work will bump into the hard and often articulated reality that different stakeholders want different things and often have either magical thinking or even self-deception about how those desires can co-exist with what everyone else wants.

This isn't a new problem by any means, but now that code is cheap, it means instead of getting frustrated with engineering and their pesky unimportant details, people will get frustrated with the AI and it's pesky unimportant details.

hombre_fatal9 days ago

Yeah, the biggest example is performance optimizations that sacrifice your data model to the point that you'd never accept them.

I think it's one reason why ADRs are an important of a software project, especially with LLMs. You need a place were you can document invariants, why you have them + the rejected ideas and acceptable risks.

It helps smart agents like Fable help you decide on trade-offs and it's kind of incredible to witness that happening.

ashkankiani8 days ago

I think they can be useful for quickly iterating through benchmarks and trying lots of ideas, but they won't come up with them on their own. Also, I'm not sure why, maybe some mean reversion thing, but they will never, ever suggest writing a tool to make their own life easier, get more accurate information, or anything. Once I point it at a tool, it can be ok at using it (I say ok because they seem to skim the help docs, which is truly ironic, considering I seem to read it more thoroughly even though I'm 100x slower at it. I assume this is some token saving system prompt), but they won't suggest it for you.

This is why I'm not worried about being replaced for now or the forseeable future. For all of the improvements they've made, this part just never seems to change. They could slap another heuristic prompt for the edge case, but eventually it'll revert to the mean again.

I think there is a way to use LLMs to help with programming, but not when I'm not the driver in the seat writing the tests and deciding the architecture. Also I would never ship code written by them as the final product for anything I care about. Since I, like most people, find reading code to be arduous. The more fun thing to do is to force yourself to rewrite it all, treating the LLM's work as a rough draft.

loeg8 days ago

> but [LLMs] won't come up with [ideas] on their own.

They can, in fact, generate plausible performance optimization ideas on their own.

hombre_fatal8 days ago

> they will never, ever suggest writing a tool to make their own life easier, get more accurate information, or anything

Make sure you process doesn't depend on anyone reading your mind.

When I run into things like this, it becomes a one-liner in my instructions/harness or in the canned prompt/skill I use that sets off a process.

In this case, I instruct agents to proactively build/improve diagnostic tooling if it would help them with their task + if it meets a bar of generalization/reusability (else it should be an ephemeral probe that gets abandoned at the end of the solution).

Capricorn24819 days ago

> If it can be measured, then LLMs can optimize it

Then they can start attempting to optimize it. They can also spin round and round making the numbers worse because they don't actually know what to do.

minimaxir9 days ago

The point of this post is that this is explicitly not the case. If the metric is measured, the agent finds a way eventually (around 5 total tries typically unless it gets stuck), and learns from iterations where changes caused a regression after a revert.

In one case I used a made-up metric (since I didn't know the exact name or if it existed) and it somehow optimized that too.

Conscat9 days ago

I had this experience at work trying to optimize a little high level Pytorch. It can't really get better than it already was, but LLMs were quite willing to pretend they will. The real solution is I need to open a PR for one of Pytorch's tracking issues.

hombre_fatal9 days ago

Yeah, but that's just the scientific process of hypothesis -> evidence -> conclusion.

You need a measurement that can falsify hypotheses and reject branches that won't work.

Also, if all you have left in your project are performance issues that are hard to identify without flailing around (even with Fable/Astra) despite sampler/profiler reports, then you're doing really well and I wouldn't assume you're going to fare much better than the sota models in terms of stabs in the dark.

loeg8 days ago

> They can also spin round and round making the numbers worse

"Claude, if this idea doesn't measure as an improvement (use X benchmark and a T-test), discard it and try the next idea."

espeed8 days ago

can LLMs write better code if you keep asking them to “write better code”?

One of the keys for me was the use of types. Typestate when functions mint witnesses that can only come from it and are required to proceed and newtypes where you use custom types instead of strings so the agent can't forget. You can also use it to force the agent to use the implementation rather than reinvent the wheel by simulating linear types. Types are a much smaller target to optimize and provide constraints that fail loudly at compile time.

vatsachak9 days ago

I've found that this is a good way to introduce bespoke code into the codebase whose perf gains don't generalize.

Unless its an easy memory/parallel/algorithmic win, its not worth it.

Read the full thread on Hacker News →

65 comments

Related stories