HN Reader

The related post on performance optimization is extremely interesting, in particular, the considerations drawn while moving from the unsafe ported code to safe¹:

> The first performance issue we hit was dynamic dispatch to assembly, as these calls are very hot. We then began adding inner mutability when necessary but had to carefully avoid contention. We found as we removed pointers and transitioned to safe Rust types that bounds checks increasingly became a larger factor. Buffer and structure initialization was also an issue as we migrated to safe, owned Rust types.

Based on their conclusions², each of those issues amounts to a few percentage points (total: 11%).

Based on the article, it seems that with highly complex logic, safety does come at the cost of raw performance, and it can be very hard to compensate (withing the safety requirements).

[¹]: https://www.memorysafety.org/blog/rav1d-performance-optimiza...

[²]: https://www.memorysafety.org/blog/rav1d-performance-optimiza...

$20K sounds very low for the effort and expertise that are demanded here in my opinion. It would be quite a steal to bring this to the same level as the state of the art (which, correct me if I'm wrong, but I believe is dav1d?) for only that sum.

Anyone who wants to offer a bounty on GitHub can try https://algora.io

It’s an open source platform (built in Elixir) for sharing bounties, contract work and full-time jobs with open source engineers

I’m one of the founders, feel free to reach out ioannis@algora.io

I'd love it if someone started Kaggle for software optimization

Welp,

> The contest is open to individuals or teams of individuals who are legal residents or citizens of the United States, United Kingdom, European Union, Canada, New Zealand, or Australia.

So most countries where putting in the effort would actually be worth the bounty offered is a no go...

I understand.

More resources for getting paid to do open source:

https://github.com/fossjobs/fossjobs/wiki/resources

from https://www.memorysafety.org/blog/rav1d-performance-optimiza...

rav1d is transpiled c-to-rust version of dav1d, compiled using Clang18 for dav1d and relevant Clang18-LLVM backend code for rustc.

Measurements showed rav1d was 3.8% slower than dav1d. Hacking up a rustc to turn off bounds checking showed rav1d-no-bounds-check was 3% slower than dav1d.

So rustc bounds checking resulted in <1% total slowdown from dav1d.

Another theory about slowdown was due to overflow checking with signed arithmetic. Further tests showed only isolated incidents of slowdown due to overflow arithmetic checking.

According to perf counters, rav1d executed 7% more instructions than dav1d. Approximately 2% of 7% is due to bounds checking.

More info about subtle interactions with changing transpiled code to idiomatic Rust in the article.

  "After applying the optimization techniques discussed here (and more), we have reduced performance overhead from a peak of about 11% when we started optimizing the safe Rust implementation in earnest to under 6% now on x86_64. We believe there is still room for further improvement, both in how the compiler optimizes Rust and in our implementation details. This will necessarily be a process of small, incremental improvements, as our profiling now indicates that the remaining overhead is spread roughly evenly across the largest, most complex functions in rav1d."

I had always kind of hoped that somebody would try to build production decoders using something like Halide. [1]

[1] https://dl.acm.org/doi/10.1145/3150211

Confirms Rust is about where I thought it was. In a strange niche where you don’t need 100% the performance of C, but the 90% you get from a managed language isn’t enough. And you can’t run on the GPU.

For the purpose of an experiment, I would love to see $20k also offered to eek out more performance on the dav1d decoder, otherwise this is just a measure of how much money people are willing to pour into optimisations.

The official rules include this interesting bit:

> Solutions must be in either rav1d itself, the Rust compiler (inclusive of llvm), or the Rust standard library.

just curious, why asian people not eligible?

$2mil would be the minimum.

> Our Rust-based rav1d decoder is currently about 5% slower than the C-based dav1d decoder (the exact amount differs a bit depending on the benchmark, input, and platform). This is enough of a difference to be a problem for potential adopters

I'm really surprised that a 5% performance degradation would lead people to choose C over Rust, especially for something like a video codec. I wonder if they really care or if this is one of those "we don't want to use Rust because of silly reasons and here's are reasonable-sounding but actually irrelevant technical justification"...

This time you cannot phone a chatbot (ChatGPT, Claude, Gemini) to help you on this one.

It has to be, you know correct?

Code bounties are unethical. I will absolutely die on this hill. You benefit from everyone's work, yet only one (or a select few) maybe get paid (in this case a pitiful amount, considering the required expertise).

Almost universally, people attempting a bounty are in a dire financial situation. You’re just taking advantage of them.

This pays for at most a week of work. I doubt it is worth anyones time to do unless they would do it for free anyway. Between the risk that someone else does it first and gets the reward and that if you are trying to make a living you need to spend time finding the next thing it just isn't much.

if you can fund someone for at least 6 months of work it becomes reasonable to work for these.

Edit: Looks like many people are not understanding how overhead works. Your take home pay over a year is just over $100,000 since you end up so much unpaid time looking for the next gig.