Synchronisation in .NET – Part 3: Spinlocks and Interlocks/Atomics
In the previous instalments (Part 1 and Part 2) of this series, we have drawn some conclusions about both .NET itself and CPU architectures. Here is what we know so far:
- When there is contention on a single cache line, the
lock()method scales very poorly and you get negative scale the moment you leave a single CPU core. - The scale takes a further dip once you leave a single CPU socket
- Even when we remove the
lock()and do racy operations, scalability is still poor - Going from a standard struct to a padded struct provides a scale boost, though not enough to get linear scale
- The maximum theoretical scale we can get with the current technique is around 90K operations/ms.
In this blog entry, I will explore other synchronisation primitives to make the implementation un-racy again.
We will be looking at spinlock and Interlocks.