Lecture

Lock-Free Synchronization: Performance and Scalability

Graph Chat

Chat with Graph Search

Ask any question about EPFL courses, lectures, exercises, research, news, etc. or try the example questions below.

DISCLAIMER: The Graph Chatbot is not programmed to provide explicit or categorical answers to your questions. Rather, it transforms your questions into API requests that are distributed across the various IT services officially administered by EPFL. Its purpose is solely to collect and recommend relevant references to content that you can explore to help you answer your questions.

Description

This lecture by the instructor provides insights into lock-free synchronization, focusing on performance and scalability. Topics covered include distributed computing platforms, hardware acceleration, software transactional memory, fine-grained synchronization challenges, and the importance of synchronization in achieving system performance. The lecture delves into the complexities of synchronization, the impact on performance, and the trade-offs between lock-based and lock-free approaches. Practical examples such as unique identifier generation and messaging queues are discussed, highlighting the benefits and challenges of different synchronization methods. The lecture concludes with a detailed exploration of atomic RDMA reads and the implications for ensuring read atomicity in distributed systems.

Official source

Related concepts (32)

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.

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.

Concurrency control

In information technology and computer science, especially in the fields of computer programming, operating systems, multiprocessors, and databases, concurrency control ensures that correct results for concurrent operations are generated, while getting those results as quickly as possible. Computer systems, both software and hardware, consist of modules, or components. Each component is designed to operate correctly, i.e., to obey or to meet certain consistency rules.

Distributed computing

A distributed system is a system whose components are located on different networked computers, which communicate and coordinate their actions by passing messages to one another. Distributed computing is a field of computer science that studies distributed systems. The components of a distributed system interact with one another in order to achieve a common goal. Three significant challenges of distributed systems are: maintaining concurrency of components, overcoming the lack of a global clock, and managing the independent failure of components.

Related lectures (33)

Lock-Free Synchronization: Practical Insights

Explores the significance of lock-free synchronization for achieving low latency in distributed systems and discusses practical solutions for unique identifier generation and messaging queues.

Concurrency Semantics and Verification

Explores concurrency semantics, recursive functions, loops, interleaving modeling, and interpreter verification.

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.

Concurrency and Mutual Exclusion

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

Transactional Memory: Hardware Simplification