Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > comp.lang.pascal.misc > #2662

Why have i invented scalable RWLocks and scalable Locks ?

Show all headers | View raw

Hello...


Why have i invented scalable RWLocks and scalable Locks ?

Because there is a disadvantage with Transactional memory and
here it is:

About Hardware Transactional Memory:

"As someone who has used TSX to optimize synchronization primitives, you 
can expect to see a ~15-20% performance increase, if (big if) your 
program is heavy on disjoint data access, i.e. a lock is needed for 
correctness, but conflicts are rare in practice. If you have a lot of 
threads frequently writing the same cache lines, you are probably going 
to see worse performance with TSX as opposed to traditional locking. It 
helps to think about TSX as transparently performing optimistic 
concurrency control, which is actually pretty much how it is implemented 
under the hood."

Read more here:

https://news.ycombinator.com/item?id=8169697


So as you are noticing, HTM (hardware transactional memory) and TM can 
not replace locks when doing IO and when we have a highly contended 
critical section.


Read the rest:


I have just read the following article that appeared in C/C++ Users 
Journal, 23(3), March 2005

The Trouble With Locks

http://gotw.ca/publications/mill36.htm


And here is my thoughts about how to avoid deadlocks and race conditions
in lock-based systems:

https://community.idera.com/developer-tools/general-development/f/getit-and-third-party/71464/about-turing-completeness-and-parallel-programming

Also i don't agree with him about composability of lock-based systems,
read the following to understand:

"About composability of lock-based systems now:

Design your systems to be composable. Among the more galling claims of 
the detractors of lock-based systems is the notion that they are somehow 
uncomposable:

“Locks and condition variables do not support modular programming,” 
reads one typically brazen claim, “building large programs by gluing 
together smaller programs[:] locks make this impossible.”9 The claim, of 
course, is incorrect. For evidence one need only point at the 
composition of lock-based systems such as databases and operating 
systems into larger systems that remain entirely unaware of lower-level 
locking.

There are two ways to make lock-based systems completely composable, and 
each has its own place. First (and most obviously), one can make locking 
entirely internal to the subsystem. For example, in concurrent operating 
systems, control never returns to user level with in-kernel locks held; 
the locks used to implement the system itself are entirely behind the 
system call interface that constitutes the interface to the system. More 
generally, this model can work whenever a crisp interface exists between 
software components: as long as control flow is never returned to the 
caller with locks held, the subsystem will remain composable.

Second (and perhaps counterintuitively), one can achieve concurrency and
composability by having no locks whatsoever. In this case, there must be
no global subsystem state—subsystem state must be captured in 
per-instance state, and it must be up to consumers of the subsystem to 
assure that they do not access their instance in parallel. By leaving 
locking up to the client of the subsystem, the subsystem itself can be 
used concurrently by different subsystems and in different contexts. A 
concrete example of this is the AVL tree implementation used extensively 
in the Solaris kernel. As with any balanced binary tree, the 
implementation is sufficiently complex to merit componentization, but by 
not having any global state, the implementation may be used concurrently 
by disjoint subsystems—the only constraint is that manipulation of a 
single AVL tree instance must be serialized."

Read more here:

https://queue.acm.org/detail.cfm?id=1454462



Thank you,
Amine Moulat Ramdane.

Back to comp.lang.pascal.misc | Previous | Next | Find similar

Thread

Why have i invented scalable RWLocks and scalable Locks ? Wisdom90 <d@d.d> - 2020-06-11 18:31 -0400

csiph-web