Lecture

Distributed Transactions: Coordination, Concurrency Control, and Recovery

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.

Related lectures (64)

Parallelism and Concurrency

Covers the course CS206 on Parallelism and Concurrency, including logistics, materials, exercise sessions, labs, exams, and grading criteria.

Akka Streams: Programming Reactive Systems

Covers Akka Streams basics, stream stages concurrency, materialized values, and more.

Distributed Transactions: 2PC Principles and Replication Strategies

Explores 2PC principles, failure scenarios, and replication strategies in distributed transactions and discusses the transition from ACID to BASE properties in NoSQL systems.

Eventual Consistency

Explores eventual consistency in distributed systems, discussing challenges, tradeoffs, and practical applications.

Concurrency and Mutual Exclusion

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

Asynchronous Programming with Futures

Explores asynchronous programming with futures, showcasing benefits, challenges, and efficient implementations.

Synchronization Inference

Explores automatic synthesis of correct and efficient synchronization in programs, focusing on removing redundant atomicity and adding synchronization metadata.

Actors: Evolution and Implementation

Covers the evolution of Actors, challenges of modern CPUs, parallel programming risks, and synchronization tools in Scala.

Concurrency Basics: Threads and Synchronization

Covers the basics of concurrency, focusing on threads and synchronization, including thread joining and challenges of non-deterministic execution.

Sequential consistency: Basic Concepts

Explains the Sequential Consistency model in concurrency and parallelism, covering program order, atomicity, and performance implications.

Parallel Programming: Fundamentals

Covers the basics of parallel programming, including exploiting parallelism in algorithms and the importance of avoiding race conditions.

Concurrency and transactional memory in Dafny

Covers Dafny for formal verification, modeling concurrency, safety rules, liveness, and transactional memory concepts.

Concurrency and Parallelism: Visibility

Explores visibility in concurrency, memory models, shared memory, and hardware optimizations.

Atomic Operations: Basics and Applications

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

Memory Models: Visibility and Semantics

Explains the Java Memory Model and thread start semantics for concurrent programs.

Concurrency Primitives and Pitfalls

Explores concurrency primitives, mutual exclusion, and synchronization pitfalls in operating systems, focusing on condition variables and semaphores.

Parallel Programming in Scala: Computing p-norm

Explores computing p-norm using parallel programming in Scala and its impact on performance.

Readers-writer Lock

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

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 and Parallelism: Queue

Explores thread safety, synchronization, and concurrent collections in Scala, focusing on a lock-free concurrent queue implementation.