Implementation of scalable blocking locks using an adaptive thread scheduler

Abstract

Blocking locks are commonly used in parallel programs to improve application performance and system throughput. However; most implementations of such locks su[fer.from two major pmhlems -latency and scalability In this paper; we pmpose an implementation of blocking locks using scheduler adaptation which exploits the interaction between thread schedulers and locks. By experimentation using wellknown multiyrocessor. applications on a KSR2 multipi-ocessor; we demonstrate how such an implementation considerably reduces the latency and improves the scalability of blocking locks.

A middleware toolkit for client-initiated service specialization

“…Such adaptations must be rapid and often must be synchronous in order to be valid. This work holds significant potential in terms of allowing programs, system abstractions and even operating systems to adapt to changing usage and resource situations [20,17].…”

Smartlocks

“…Problems arise when a running thread spins, waiting for action from another thread that is swapped out. [9] and [8] develop lock strategies to improve such interactions between locks and the kernel scheduler and avoid descheduling threads at inconvenient times. The preemption-safe ticket locks, queue locks, and scheduler-conscious queue locks from these works could be included in Smartlocks' dynamic repertoire of lock strategies -as could future developments in scalable algorithms.…”

A scalable and starvation-free concurrent locking mechanism

“…The implementation could be said to follow an oblivious scheme, in which the same strategy is used under all system states. This is in contrast to methods which make use of adaptive thread scheduling [6] in order to improve system performance. However, the latter approach is most applicable when lock access is expensive compared to local thread management (for example, when the lock implementation serialises the processor requests).…”