Lecture

Transactional Memory: Hardware Concurrency Control

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)

Memory Consistency II

Explores speculative memory consistency, challenges, solutions, performance overhead, and the impact of dynamic fence enforcement on achieving high performance.

Memory Consistency: Basics and Models

Explores memory consistency in multiprocessor systems, discussing coherence, consistency models, and the trade-offs between ordering constraints and performance.

Dining philosopher problem

Presents an algorithm to prevent starvation and maximize philosophers eating simultaneously.

Caches - Performance

Explores cache memory performance evaluation, covering benchmarks, Amdahl's law, CPU performance, memory hierarchy, cache optimizations, and multilevel caches.

Online Algorithms: Competitive Ratio

Covers online algorithms and competitive ratio in caching strategies to optimize memory usage.

Optimizing Software: Software Optimizations

Covers software optimizations to improve program performance by maximizing cache hits and optimizing work distribution.

Multithreading: Pipeline Utilization and Performance Impact

Explores multithreading in computer architecture, focusing on pipeline utilization and performance impact in various techniques, including blocked and fine-grained multithreading.

Transitioning to Multithreaded Programming: Key Concepts

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

Introduction to Database Systems

Covers the basics of database systems, including data modeling, DBMS, data independence, and the course overview.

Concurrency and transactional memory in Dafny

Covers Dafny basics, modeling concurrency, and implementing transactional memory with safety and liveness proofs.

Cache Memory

Explores cache memory design, hits, misses, and eviction policies in computer systems, emphasizing spatial and temporal locality.

Akka Streams: Programming Reactive Systems

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

Concurrency Basics: Threads and Synchronization

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

Introduction to Concurrency

Covers the basics of concurrency, its importance, and how to write concurrent programs.

Principles of Locality

Explores the impact of locality on system design, discussing strategies to optimize efficiency and performance through data layout, lock design, and data movement minimization.

Sequential consistency: Basic Concepts

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

Isolation and Protection: Ensuring Process Security

Covers the concepts of isolation and protection in computer systems, focusing on process security and resource management techniques.

Introduction to Multicore Processors

Covers the shift to multicore processors, processor-memory architecture, concurrency challenges, and synchronization problems in modern computing.

Threads: Concurrency and Parallelism in Computer Systems

Covers the thread abstraction in computer systems, focusing on concurrency, parallelism, and the management of threads using the POSIX API.

Locks: Implementing Concurrency Mechanisms

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