http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47031
--- Comment #2 from Nicola Pero <nicola at gcc dot gnu.org> 2010-12-29 16:10:51 UTC --- I'm actually not very convinced by this any more; we probably need some benchmarks. ;-) The problem is that property accessors are basically general purpose routines that may be used in the most varied situations. So, we have very little control or knowledge over when and how they are used -- * we don't know how many CPUs or cores the user has * we don't know how many threads the user is starting * we don't know how many threads are sharing a CPU or core * we don't know how intensively the user is using the property accessors Spinlocks are appropriate when certain conditions are met; but in this case, it seems impossible to be confident that these are met. A user may write a program with 3 or 4 threads running on his 1 CPU/core machine, which constantly read/write an atomic synthesized property to synchronize between themselves. Why not; but then, spinlocks would actually degrade performance instead of improving it. Traditional locks may be slower if you a low contention case, but work consistently OK in all conditions. For me, the key problem is that: * spinlocks are better/faster if there is low contention and very little chance that two threads enter the critical region (inside the accessors) at the same time. * the difference in performance between mutexes and spinlocks only matters in the program performance if the accessors are called very often. But these two things conflict with each other ;-) For example, if a spinlock makes the accessor 2x as fast as with a mutex, but the program only spends 0.1% of its time calling the accessors, then the difference in performance on the whole program would be of the order of 0.05%; then, we prefer a mutex since the performance is more consistent and it has no "worst-case" scenarios. If the program spends more (say, 10%) of its time calling the accessors, then the difference in performance would matter (it would be something like 5%), but because the program is spending so much time in accessors, if the program is multi-threaded there is high contention, and spinlocks don't perform well any more - in fact, the worst-case scenarios (where lots of CPU is wasted spinning and making no progress) may appear. (keep in mind that as we're sharing locks across different objects/properties, even if the different threads are calling accessors of different objects/properties, the locks would still be contended). The only case where spinlocks really help is if the program spends lots of time calling accessors, and is not multi-threaded. In which case, the programmer could get a huge speed-up by simply declaring the properties non-atomic. So, I'm not sure there is a good case for spinlocks. It may be good to try some benchmarks to get a feeling for the difference in performance between mutexes and spinlocks. Would using spinlocks make accessors 2x faster ? 10x faster ? 10% faster ? Thanks
