squirrellous

Cool! Thanks for the example. The aforementioned work thing requires MAP_SHARED as well which IIRC is the reason it would fail when used together with files and huge pages, but private mappings work as you show.

This is quite interesting since I, too, was under the impression that mmap cannot be used on disk-backed files with huge pages. I tried and failed to find any official kernel documentation around this, but I clearly remember trying to do this at work (on a regular ECS machine with Ubuntu) and getting errors.

Based on this SO discussion [1], it is possibly a limitation with popular filesystems like ext4?

If anyone knows more about this, I'd love to know what exactly are the requirements for using hugepages this way.

[1] https://stackoverflow.com/questions/44060678/huge-pages-for-...

Adding another positive note here. It works at incredible speeds in Cursor which allows me to iterate on prompts faster and not worry much about throwing away unsatisfactory work. This makes up for a lot of smaller issues if you know how to direct it. Output quality is decent too, at least for the problems I’ve tried.

It’s good for well defined tasks. Less good if you need it to be autonomous for long periods.

Respectfully, the article needs more punctuation. Having a strictly grammar-correcting GPT pass would be good.

To stay on topic, I’d really like to know if something like this exists today for native c++ / c programs. I haven’t really found an easy to set up, low overhead heap profiling tool that can be left on in production.

FWIW I resonate a lot with what the author says about the art of multiprocessor programming. When I learned it in college (from the author himself no less), it felt like a very theoretical introduction to a deeply practical problem domain. I could complete the practice problems well, but that didn’t teach me the intuition for writing multithreaded programs. Later on once I’ve been through the trenches in the industry and came back to the book, everything started to make more sense and I started to see parallels with distributed systems.

Honestly I think if you really want to understand this topic, getting exposed to atomic memory ordering early on and writing simplified spin locks / SPSC queues is the way to go. You don’t even have to implement them correctly - the implementation just needs to teach you what could go wrong. The book operates at an abstraction level that makes it not very useful inexperienced students.

The free usage gets exhausted really fast. I had a similar experience as the parent where I easily burned through $70+ in two days with two requests in a medium size codebase. Then I switched to free, and it couldn’t finish a single request end to end.

On top of this Gemini CLI still doesn’t support paying through the Google AI subscription. I assume it’s some sort of bureaucratic reason that’s preventing them from moving quickly.

Congrats! Would you mind sharing what part of the design makes this faster than the competitors?

True but misleading. Like one of the other commenters also mentioned, most integers are small. For 32-bit you might run into integers above 2^23 bits once in a while, but for 64-bits it’s really not that common to have integers above 2^53, unless it’s a bit pattern instead of a natural number. So you could reasonably say “most integers _are_ 64-bit floats.”

Exciting. Imagine shipping GCC at runtime and compiling a whole new program from a JSON configuration file, optimized to exactly that configuration.

It’s about jobs and livelihoods, even if not everyone will admit it. It’s easy to emotional when the argument boils down to “your skills are now outdated, go learn a better one”.

This might be a naive question - does this approach mean that the application and the kernel is now a single binary, and thus application crashes now translate to kernel panics? I guess now that we have docker it isn’t such a big deal, but otherwise it places a lot of confidence on the robustness of the application itself.

Just wanted to say that to me, this series is the holy grail of breaking down an inscrutably technical topic with decades of research behind it into understandable language, while at the same time retaining all the necessary complexities and not “dumbing down” anything. Truly a delight to read if you are interested in the topic. I can only aspire to be a writer like Russ some day.