3 ms·
So the takeaway here is apparently that POSIX mutexes on macOS/iOS are really slow due to an oddball design decision (fairness), and the browser vendors are rac
by ajross 10y ago
So the takeaway here is apparently that POSIX mutexes on macOS/iOS are really slow due to an oddball design decision (fairness), and the browser vendors are racing to see who can reimplment them best. Windows and Linux do this just fine AFAICT.
Seems like it would be more effective for the WebKit folks to just work on their Darwin compatriots to fix the C library locks, no?
- Jweb_Guru 10y agoFairness isn't an oddball design decision, it's an important assumption that many realtime systems rely on.
- ajross 10y agoIt's oddball in the sense that literally no one else does it. So I don't know what systems you mean, since by definition they don't run on Linux (glibc or bionic) or Windows. I'm not saying there's no use case for a fair mutex anywhere (though I'll come really close and say that if you want fairness a lock is the wrong abstraction), I'm saying that stuffing a context switch into every contended call to pthread_mutex_unlock() is a terrible design decision.
- Jweb_Guru 10y agoIf you don't need fairness, don't use a fair lock. The default assumption should be fairness because it doesn't require you to think (just like the default transaction isolation level should be serializable). As the blog post points out, OS X provides unfair mutexes too. Windows locks are fair by default too, BTW (IIRC anyway). People just use the unfair version when they need performance.
- striking 10y agohttp://www.pcdoctor-community.com/wp/posts/2007/10/fairness-in-win32-lock-objects/ http://www.pcdoctor-community.com/wp/posts/2007/10/fairness-... Windows XP tried to implement some amount of fairness in its locks but did not guarantee it. Windows Vista gave up on fairness entirely. You should just be using unfair locks. Thread starvation is rare in most OSes at this point.
- eridius 10y agoThread starvation is still very much a thing on a lot of devices. macOS and iOS even have a Quality Of Service implementation in the kernel specifically to ensure that high-priority threads get to run when they'd otherwise be starved, and this can lead to low-priority threads being suspended for many seconds at a time under high workload. In fact, it's now really dangerous to use a regular spinlock on iOS and macOS because you can get into a priority inversion livelock if threads from different QoS levels are contending the same lock. The Obj-C runtime was seeing delays of tens of seconds in some cases when using spinlocks, so it now uses a private "os_lock" which is a spinlock that uses SPI to "donate" the QoS of the waiting thread to the one that holds the spinlock.
- LeoNatan25 10y agoAs of iOS 10 and macOS 10.12, it is no longer private: `os_unfair_lock`. https://developer.apple.com/reference/os/os_unfair_lock https://developer.apple.com/reference/os/os_unfair_lock
- eridius 10y agoOh good! I'll have to do some research at some point to find out if this is literally the same thing as the os_lock that the Obj-C runtime uses, but either way, I'm glad it's available now.
- LeoNatan25 10y agoIt uses the same private API (or at least, what you described in your previous post).
- rbehrends 10y agoIt's not as simple as that. What makes locks expensive (no matter their policy regarding fairness) is blocking. Blocking leads to context switches, which are extremely expensive. Linux not using fairness does not eliminate that problem, it mitigates it (which is a good thing, just not a panacea). I have a simple benchmark that loses performance the more you parallelize it beyond 4-6 cores, until eventually it becomes slower than the single-threaded case [1]. And contention on that is not actually that high. That's still better than the macOS case, where performance goes to hell for even two threads, of course. Here's the output of time for 32 threads (running on a 48-core system): ./a.out -p 32 7.72s user 75.04s system 2603% cpu 3.179 total as opposed to the sequential case: ./a.out -p 0 1.94s user 0.00s system 99% cpu 1.942 total As you can see, the program spends the vast majority of the time in the kernel due to blocking constantly. (Note that other factors add to the overhead, too.) In short, you do not want a high degree of contention, anyway. The macOS locks just make contention hurt much more. [1] https://gist.github.com/rbehrends/27a1ca27ddec7016cd42428b9c27e89e https://gist.github.com/rbehrends/27a1ca27ddec7016cd42428b9c...