Scheduler-conscious synchronization

Abstract

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.

Preemption Adaptivity in Time-Published Queue-Based Spin Locks

“…Finally, several researchers have suggested operating system mechanisms that provide user applications with a limited degree of control over scheduling, allowing them to avoid [4,5,14,19,25] or recover from [1,2,31,33] inopportune preemption. Commercial support for such mechanisms, however, is neither universal nor consistent.…”

“…Extending previous work [14], we distinguish three levels of APIs for user-level feedback to the kernel scheduler implementation: (I) Critical section protection (CSP): these APIs can bracket a block of code to request that a thread not be preempted while executing it. (II) Runtime state check: these APIs allow inquiries as to whether a thread is currently preempted.…”

“…For Test-and-Set (TAS) locks, preemption-safe variants need only a Level I API [14] to avoid preemption during the critical section of a lock holder. By comparison, a thread contending for a (non-abortable) queue-based lock is sensitive to preemption in two additional timing windowswindows not addressed by the preemption adaptivity of the MCS-TP and CLH-TP locks.…”

“…Previous work proposed two algorithms for preemption-safe MCS variants: the Handshaking and SmartQ locks [14]. Both require a Level I API to prevent preemption in the critical section and in the first (linking-in) window described above.…”

A Transparent Operating System Infrastructure for Embedding Adaptability to Thread-Based Programming Models

“…The literature provides a wealth of solutions for attacking the performance bottlenecks that arise from the interference between multiprocessing and multiprogramming [1,3,6]. However, little effort has been spent on the transparent integration of these solutions and multithreading programming models in a generic, model-independent manner.…”