Too often people mistake the algorithmic complexity theory for the real performances you would get. This can't be further from the truth. The memory layout trumps all. As usual you need to measure.
They're definitely handling this part right, they seem well ahead everyone else.
Nice post on how to approach problems suitable for SIMD.
Excellent piece diving deep into the opportunities to optimise an algorithm. The final speed up is impressive.
Interesting experiment on how to totally break the performance of memory accesses. This gives good insights on the whole chain works.
Nice exploration of floating point arithmetic all the way down to the silicon.
Wondering about NPUs architecture and how they work? This is a good in depth reference article I think.
Not all CPUs are born equal in term of branch prediction. Interesting little benchmark.
Nice little introduction in the fascinating world of very large binaries.
Maybe we have a path forward for performance stackful coroutine? More pieces need to fall in place but this looks promising.
Interesting to see how it behaves in practice when passing parameters by value. Turns out there are surprising patterns in the data.
If you're wondering why the architecture is called "amd64" and why the itanium disappeared... this is why. It was a very good stunt from AMD back then.
Interesting trend in the CPU space. We're getting more simultaneous instructions with the passing generations.
Indeed, CPU prefetchers are really good nowadays. Now you know what to do to keep your code fast.
SIMD instructions are indeed a must to get decent performance on current hardware.
A good example of how you can get bitten by cache coherency algorithms in the CPU.
A bit dated perhaps, and yet most of the lessons in here are still valid. If performance and parallelism matter, you better keep an eye on how the cache is used.
Nice trick for highly performance sensitive data structures. Making data CPU local instead of thread local you can make a mechanism which is especially cache friendly.
Nice exploration of the microcode patching flaw which was disclosed recently. This gives a glimpse at the high level of complexity the x86 family brings on the table.
Nice primer on the impact of too many branches in your code on the CPU. This is sometimes a good way to boost performance when you're mindful about that.