Lecture

Memory Models: Visibility and Semantics

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)

Principles of Parallelism

Covers the basics of parallelism, including physical examples, historical context, multicore era, and parallel collections in Scala.

Concurrency: Deadlock

Covers the concept of deadlock in concurrent programming and provides solutions to prevent them.

Dining Philosophers Problem

Discusses algorithms to prevent starvation and maximize philosophers eating simultaneously.

Memory Consistency: Programming Languages and Compilers

Explores memory consistency, data races, and synchronization variables in programming languages and compilers.

Parallelism and Concurrency

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

Readers-writer Lock

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

Transaction Management & Concurrency Control

Explores transaction management, concurrency control, ACID properties, anomalies, and conflict serializability in database systems.

Locks: Implementing Concurrency Mechanisms

Covers the implementation of locks using compareAndSet and the concept of fair locks.

Lock-Free Synchronization: Performance and Scalability

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

Comparing Objects: Comparable vs Comparator

Covers the concepts of Comparable and Comparator interfaces in Java, explaining how classes implement these interfaces to enable object comparison.

The Power of Registers

Covers wait-free implementations of atomic objects, focusing on counters and snapshots, discussing key ideas for enforcing atomicity and wait-freedom.

Design Patterns: Observer

Covers the implementation of the Observer design pattern in Java.

Memory Consistency Models: Performance Impact and Parallel Computing

Covers memory consistency models, parallel computing, atomic subroutines, GPU architecture, and multithreading.

Transitioning to Multithreaded Programming: Key Concepts

Covers the transition from single-threaded to multithreaded programming, focusing on memory models and consistency issues.

Concurrency Overview

Explores the significance of concurrency in enhancing system performance and responsiveness, emphasizing the need for synchronization and atomicity to prevent race conditions and non-determinism.

Asynchronous Programming with Futures

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

Concurrency with Executors

Covers the basics of concurrency properties, Executors, Runnable objects, ForkJoinPool, task completion handling, execution contexts in Scala, and simplifying task execution.

Locking Primitives: Avoiding Race Conditions in Threads

Covers locking primitives necessary to prevent race conditions in multithreaded programming, focusing on mutual exclusion and atomic operations.

Parallelism: Programming and Performance

Explores parallelism in programming, emphasizing trade-offs between programmability and performance, and introduces shared memory parallel programming using OpenMP.

One place buffer: Producer-consumer queue

Introduces the concept of a one-place buffer in concurrent programming.