News for hackers. Stuff that matters.
Re:The Fastest Mutexes by secondcoming on Wednesday October 02, 2024 @06:48PM (#41725653)
`rep; nop;` is actually the `pause` instruction. On older CPUs it’s a standard nop, but on newer CPUs it’s a more efficient nop.

Spinning on the CMPXCHG is also a bad idea. You should spin on the read and only then attempt the CMPXCHG.

Re:The Fastest Mutexes by bobmcnamara on Wednesday October 02, 2024 @08:51PM (#41726308)
Bingo. Spinning on CMPXCHG can cause livelock.
Re:The Fastest Mutexes by epcoa on Thursday October 03, 2024 @02:54AM (#41727946)
Just to clarify: the spinning on CMPXCHG is not also a bad idea, the YieldProcessor is correct (a pause), but inside the CMPXCHG loop it should be spinning on a pure unlocked load. Is that correct?
Re:The Fastest Mutexes by secondcoming on Thursday October 03, 2024 @04:53AM (#41728684)
No you should spin on a read. Once you see the value you want you then try the CMPXCHG. If that succeeds you exit. If it fails you go back to spinning on the read.
Re:The Fastest Mutexes by epcoa on Thursday October 03, 2024 @10:24AM (#41731094)
What is the difference between a read and a “load” here?
Re:The Fastest Mutexes by loeg on Thursday October 03, 2024 @12:38PM (#41732347)
Read and load mean the same thing. (I think GP just missed the end of your comment.)

You care about exchange vs read/load because of cache line ownership. Every time you try to do the exchange, the attempting CPU must take exclusive ownership of the cacheline (stealing it from the lock owner). To unlock, the lock owner must take it back.

If the attempting CPU instead only reads, the line ownership stays with the lock holder and unlock is cheaper. In general you want cache line ownership to change hands as few times as possible.

Re:The Fastest Mutexes by pizlonator on Thursday October 03, 2024 @08:58AM (#41730366)
Spinning with pause is slower than spinning with sched_yield according to every test I’ve ever done
Re:The Fastest Mutexes by epcoa on Thursday October 03, 2024 @10:48AM (#41731309)
For what it is worth it seems the library in question does both, uses an exponential retry loop, busy read looping 2^i times for the first 7 attempts before then yielding. It seems like there must be some threshold where latency is improved by retrying before yielding, but I don’t test these things for a living.

https://github.com/google/nsync/blob/c6205171f084c0d3ce3ff51...

Re:The Fastest Mutexes by pizlonator on Thursday October 03, 2024 @12:43PM (#41732395)
My data says that always yielding is better than ever busy spinning, except on microbenchmarks, where depending on the microbenchmarks you can get any answer your heart desires.
Re:The Fastest Mutexes by Animats on Thursday October 03, 2024 @01:39PM (#41732909)
I've tried to figure out where that goes wrong. Read the bug report linked. I've caught this situation in gdb with 20 threads in spinlocks inside realloc, performance in a game down to 1 frame every 2 seconds, and very little getting done. But I don't understand how the three levels of locking involved cause that. Nor do the Wine people.

Works fine on Microsoft Windows. Only fails on Wine.

Re:The Fastest Mutexes by epcoa on Thursday October 03, 2024 @03:01PM (#41733794)
It seems like the loop around InterlockedCompareExchange is a bad idea since this is a bus lock in a tight loop. Rather the inner spinning loop that is yielding should just be reading the value surrounded by the cmpxchg. As for whether sched_yield should just be called in the inner loop or a short nop/pause loop should be attempted for microcontention reasons, the expert opinion here is don't bother with the nop loop. However while the nop loop might not be real world optimal I doubt that would be causing a catastrophic performance issue.