A Fair Fast Scalable Rea,der-Writer Lock

Krieger, Orran; Stumm, Michael; Unrau, Ronald C.; Hanna, Jonathan

doi:10.1109/icpp.1993.21

Cited by 30 publications

(29 citation statements)

References 4 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Preempting and scheduling processes in an order inconsistent with their order in the lock's queue can degrade performance dramatically. Kontothanassis et al [18] present preemption-safe (or "scheduler-conscious") versions of the ticket lock, the MCS lock [25], and Krieger et al's reader-writer lock [19]. These algorithms detect the descheduling of critical processes using handshaking and/or a widened kernel-user interface, and use this information to avoid handing the lock to a preempted process.…”

Section: Preemption-safe Lockingmentioning

confidence: 99%

Nonblocking Algorithms and Preemption-Safe Locking on Multiprogrammed Shared Memory Multiprocessors

Michael¹,

Scott²

1998

Journal of Parallel and Distributed Computing

156

146

View full text Add to dashboard Cite

Most multiprocessors are multiprogrammed in order to achieve acceptable response time and to increase their utilization. Unfortunately, inopportune preemption may significantly degrade the performance of synchronized parallel applications. To address this problem, researchers have developed two principal strategies for concurrent, atomic update of shared data structures: (1) preemption-safe locking and (2) non-blocking (lock-free) algorithms. Preemption-safe locking requires kernel support. Non-blocking algorithms generally require a universal atomic primitive such as compare-and-swap or load-linked/store-conditional, and are widely regarded as inefficient.We evaluate the performance of preemption-safe lock-based and non-blocking implementations of important data structures-queues, stacks, heaps, and counters-including non-blocking and lock-based queue algorithms of our own, in micro-benchmarks and real applications on a 12-processor SGI Challenge multiprocessor. Our results indicate that our non-blocking queue consistently outperforms the best known alternatives, and that data-structure-specific non-blocking algorithms, which exist for queues, stacks, and counters, can work extremely well. Not only do they outperform preemption-safe lock-based algorithms on multiprogrammed machines, they also outperform ordinary locks on dedicated machines. At the same time, since general-purpose non-blocking techniques do not yet appear to be practical, preemption-safe locks remain the preferred alternative for complex data structures: they outperform conventional locks by significant margins on multiprogrammed systems.

show abstract

Section: Preemption-safe Lockingmentioning

confidence: 99%

Nonblocking Algorithms and Preemption-Safe Locking on Multiprogrammed Shared Memory Multiprocessors

Michael¹,

Scott²

1998

Journal of Parallel and Distributed Computing

156

146

View full text Add to dashboard Cite

show abstract

“…This is to ensure that always the strongest possible annotation is used for gated actions. Then, each gated action whose gate does not contradict with p is annotated with p (lines [8][9][10]. Then, until a valid VC is generated, those gated actions whose modified assertions may be violated (elements of the F ailed set at line 15, returned by Z3) are restored to the values they had at the start of the outer loop iteration (lines [16][17].…”

Section: Annotating Programs -Algorithmmentioning

confidence: 99%

“…The implementation uses the num active and owner variables similar to our readers and write variables in Figure 3; a use of the lock in a program can be specified by the policy S rwlock ((num active==0 && owner==0), (num active>0 && owner==1)). The implementations in the ACE framework [14] and in [10], can be encoded similarly. Philo.…”

Section: Experiencementioning

confidence: 99%

An annotation assistant for interactive debugging of programs with common synchronization idioms

Elmas

Sezgin

Tasiran

et al. 2009

Proceedings of the 7th Workshop on Parallel and Distributed Systems: Testing, Analysis, and Debugging

View full text Add to dashboard Cite

This paper explores an approach to improving the practical usability of static verification tools for debugging synchronization idioms. Synchronization idioms such as mutual exclusion and readers/writer locks are widely-used to ensure atomicity of critical regions. We present an annotation assistant that automatically generates program annotations. These annotations express noninterference between program statements, ensured by the synchronization idioms, and are used to identify atomic code regions. This allows the programmer to debug the use of the idioms in the program. We start by formalizing several well-known idioms by providing an abstract semantics for each idiom. For programs that use these idioms, we require the programmer to provide a few predicates linking the idiom with its realization in terms of program variables. From these, we automatically generate a proof script that is mechanically checked. These scripts include steps such as automatically generating assertions and annotating program actions with them, introducing auxiliary variables and invariants. We have successfully shown the applicability of this approach to several concurrent programs from the literature.

show abstract

“…Markatos [27] uses a doubly-linked list in a queue-based lock to replace FIFO order with highest-priority-first, for real-time systems. Others have shown how to build queue-based scalable reader-writer 10cks [19,31]. Yang and Anderson [44] have shown how to use localonly spinning to improve the performance of locks that use no atomic memory operations other than loads and stores.…”

Section: Scalable Locksmentioning

confidence: 99%

Scheduler-Conscious Synchronization.

Kontothanassis¹,

Wiśniewski²,

Scott³

1994

View full text Add to dashboard Cite

Efficient synchronization is important for achieving good performance in parallel programs, especially on large-scale multiprocessors. Most synchronization algorithms have been designed to run on a dedicated machine, with one application process per processor, and can suffer serious performance degradation in the presence of multiprogramming. Problems arise when running processes block or, worse, busy-wait for action on the part of a process that the scheduler has chosen not to run.In this paper we describe and evaluate a set of scheduler-conscious synchronization algorithms that perform well in the presence of multiprogramming while maintaining good performance on dedicated machines. We consider both large and small machines, with a particular focus on scalability, and examine mutual-exclusion locks, reader-writer locks, and barriers. The algorithms we study fall into two classes: those that heuristically determine appropriate behavior and those that use scheduler information to guide their behavior. We show that while in some cases either method is sufficient, in general sharing information across the kernel-user interface both eases the design of synchronization algorithms and improves their performance.

show abstract

A Fair Fast Scalable Rea,der-Writer Lock

Cited by 30 publications

References 4 publications

Nonblocking Algorithms and Preemption-Safe Locking on Multiprogrammed Shared Memory Multiprocessors

Nonblocking Algorithms and Preemption-Safe Locking on Multiprogrammed Shared Memory Multiprocessors

An annotation assistant for interactive debugging of programs with common synchronization idioms

Scheduler-Conscious Synchronization.

Contact Info

Product

Resources

About