Introduction to Multicore Processors

About
Privacy
Disclaimer

Graph Chatbot

Related lectures (32)

Page 2 of 4

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

Concurrency Basics: Threads and Synchronization

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

Transactional Memory: Hardware Simplification

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

Transactional Memory: Hardware Simplification

Explores hardware-based transactional memory for simplifying concurrency control and improving performance in hash tables.

Concurrency and Parallelism: Visibility

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

Theoretical Foundations for Emerging Multiprocessor Technologies: RDMA and NVRAM

Explores theoretical foundations for RDMA and NVRAM in multiprocessor technologies, covering contention, concurrency control, and fault tolerance.

Dining philosopher problem

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

Actors: Evolution and Implementation

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

Locks: Implementing Concurrency Mechanisms

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

Concurrency Primitives and Pitfalls

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