Mediaspace scheduled maintenance: Aug 25, 2026 07:00 - 12:00 AM. During this time, videos will be temporarily unavailable. Check status updates.

Lecture

Lock-free synchronization: Achieving low latency

Description

This lecture by the instructor covers the importance of lock-free synchronization in achieving low latency in distributed systems. The lecture delves into topics such as hardware acceleration of high-level abstractions, software transactional memory, and the challenges of fine-grained synchronization. Various techniques for generating unique identifiers and implementing a multi-producer, single-consumer queue are discussed. The lecture also explores the design considerations for atomic RDMA reads and proposes scalable schemes for sharing connections on a network card between threads. Lock-free synchronization techniques are highlighted as crucial for high-performance distributed systems.

This video is available exclusively on Mediaspace for a restricted audience. Please log in to MediaSpace to access it if you have the necessary permissions.

Watch on Mediaspace

Official source

Related concepts (27)

Synchronization (computer science)

In computer science, synchronization refers to one of two distinct but related concepts: synchronization of processes, and synchronization of data. Process synchronization refers to the idea that multiple processes are to join up or handshake at a certain point, in order to reach an agreement or commit to a certain sequence of action. Data synchronization refers to the idea of keeping multiple copies of a dataset in coherence with one another, or to maintain data integrity.

Lock (computer science)

In computer science, a lock or mutex (from mutual exclusion) is a synchronization primitive: a mechanism that enforces limits on access to a resource when there are many threads of execution. A lock is designed to enforce a mutual exclusion concurrency control policy, and with a variety of possible methods there exists multiple unique implementations for different applications. Generally, locks are advisory locks, where each thread cooperates by acquiring the lock before accessing the corresponding data.

Linearizability

In concurrent programming, an operation (or set of operations) is linearizable if it consists of an ordered list of invocation and response events, that may be extended by adding response events such that: The extended list can be re-expressed as a sequential history (is serializable). That sequential history is a subset of the original unextended list. Informally, this means that the unmodified list of events is linearizable if and only if its invocations were serializable, but some of the responses of the serial schedule have yet to return.

Non-blocking algorithm

In computer science, an algorithm is called non-blocking if failure or suspension of any thread cannot cause failure or suspension of another thread; for some operations, these algorithms provide a useful alternative to traditional blocking implementations. A non-blocking algorithm is lock-free if there is guaranteed system-wide progress, and wait-free if there is also guaranteed per-thread progress. "Non-blocking" was used as a synonym for "lock-free" in the literature until the introduction of obstruction-freedom in 2003.

Semaphore (programming)

In computer science, a semaphore is a variable or abstract data type used to control access to a common resource by multiple threads and avoid critical section problems in a concurrent system such as a multitasking operating system. Semaphores are a type of synchronization primitive. A trivial semaphore is a plain variable that is changed (for example, incremented or decremented, or toggled) depending on programmer-defined conditions.

Related lectures (32)

Atomic Operations: Basics and Applications

Covers the basics of atomic operations in concurrency and parallelism, including hardware-provided operations and synchronized algorithms.

Readers Writer's Lock

Covers the concept of Readers Writer's lock and its synchronization between readers and writers using atomic variables.

Readers-writer Lock

Introduces the readers-writer lock for handling concurrency in scenarios with frequent reads and occasional updates.

Monitors: Synchronization and Cooperation

Explores monitors as a synchronization construct providing mutual exclusion and cooperation among threads, with examples like the one-place buffer.

Synchronization Primitives