benchmarking on Kai Striega

Pointer Chasing

Sun, 26 Jul 2026 11:20:00 +1000

Everyone who writes Python for a living has been handed the same rule: don’t use a list, use an array. It’s a good rule. I’ve given it as advice myself, probably to someone who deserved a better explanation than the one I gave.

Here is the rule being followed, on two million integers:

sum(values) # a plain list 10.0 ms
sum(values) # array('q') 19.2 ms

Swapping the list for a compact array of machine integers made it twice as slow. Nothing was measured wrongly. That is what the machine does.

False Sharing

Sat, 25 Jul 2026 14:01:54 +1000

Part one of this series had one central fact and one piece of advice. The fact was that memory moves in 64 byte cache lines, so the cost of a loop is the number of lines it touches. The advice that fell out of it was to pack your data tightly, because packing more useful bytes into each line means fetching fewer lines.

This post is about a case where packing tightly is the entire bug, and the fix is to deliberately waste 56 bytes out of every 64.

Branch Prediction

Sat, 25 Jul 2026 11:45:58 +1000

Last time I argued that your data layout is your program, because the machine reads memory in 64 byte cache lines whether you asked for 64 bytes or 4. That post was about the CPU doing something less than you expected: it can only fetch whole lines, so a lot of what it fetches is wasted.

This one is about the CPU doing something considerably stranger. It runs your code before it knows whether it should.

Array of Structs vs Struct of Arrays

Sat, 25 Jul 2026 08:50:30 +1000

I’ve been putting together a talk about the things I don’t worry about, because NumPy does them for me: the performance patterns I kept running into over seven years of reviewing NumPy code written by people far smarter than me. What an array actually is. When reshape quietly copies six gigabytes. What broadcasting promises not to allocate. I did a practice run of it at SydPy recently.

The NumPy-specific parts landed fine. Then I got to a slide which says that a copy isn’t slow because the CPU is busy, it’s slow because the bytes have to physically move; that main memory will only hand them over at something like 20 GB/s; and that while that’s happening your cache is filling up with data you will never look at again.