Lock-Free Synchronization: Practical Insights

This lecture by the instructor from Citadel Securities delves into the importance of lock-free synchronization for achieving low latency in distributed systems. The content covers topics such as hardware acceleration of high-level abstractions, software transactional memory, and the challenges of fine-grained synchronization. Practical examples and solutions for unique identifier generation, messaging queues, and scalable connection sharing are discussed. The lecture emphasizes the trade-offs between lock-based and lock-free approaches, the significance of thread-local processing, and the complexities of failure detection in real-time systems.

About this result

This page is automatically generated and may contain information that is not correct, complete, up-to-date, or relevant to your search query. The same applies to every other page on this website. Please make sure to verify the information with EPFL's official sources.

Related lectures (35)

Related concepts (89)

CS-453: Concurrent computing

With the advent of modern architectures, it becomes crucial to master the underlying algorithmics of concurrency. The objective of this course is to study the foundations of concurrent algorithms and

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.

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.

Global interpreter lock

A global interpreter lock (GIL) is a mechanism used in computer-language interpreters to synchronize the execution of threads so that only one native thread (per process) can execute at a time. An interpreter that uses GIL always allows exactly one thread to execute at a time, even if run on a multi-core processor. Some popular interpreters that have GIL are CPython and Ruby MRI. A global interpreter lock (GIL) is a mutual-exclusion lock held by a programming language interpreter thread to avoid sharing code that is not thread-safe with other threads.

Concurrent computing

Concurrent computing is a form of computing in which several computations are executed concurrently—during overlapping time periods—instead of sequentially—with one completing before the next starts. This is a property of a system—whether a program, computer, or a network—where there is a separate execution point or "thread of control" for each process. A concurrent system is one where a computation can advance without waiting for all other computations to complete. Concurrent computing is a form of modular programming.

Thread (computing)

In computer science, a thread of execution is the smallest sequence of programmed instructions that can be managed independently by a scheduler, which is typically a part of the operating system. The implementation of threads and processes differs between operating systems. In Modern Operating Systems, Tanenbaum shows that many distinct models of process organization are possible. In many cases, a thread is a component of a process.

Scalable Synchronization Mechanisms for Manycore Operating Systems

Explores scalable synchronization mechanisms for many-core operating systems, focusing on the challenges of handling data growth and regressions in OS.

Lock-Free Synchronization: Performance and Scalability CS-453: Concurrent computing

Explores lock-free synchronization for performance and scalability in distributed systems, covering unique identifier generation, messaging queues, and atomic RDMA reads.

Concurrency and Mutual Exclusion CS-323: Introduction to operating systems

Covers the importance of concurrency, atomic operations, and mutual exclusion using locks.

Locking

Explores the concept of locking for mutual exclusion in OS, covering race conditions, parallelism, atomic instructions, deadlock prevention, and best practices.

Transactional Memory: Hardware Simplification CS-307: Introduction to multiprocessor architecture

Explores transactional memory and hardware simplification for concurrency control in software, emphasizing the benefits of hardware speculation and declarative concurrency.