Mediaspace scheduled maintenance: Aug 25, 2026 07:00 - 12:00 AM. During this time, videos will be temporarily unavailable. Check status updates.

Course

CS-206: Parallelism and concurrency

Lectures in this course (61)

Concurrency and Parallelism: Queue

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

Readers Writer's Lock

Covers the concept of Readers Writer's lock and its synchronization between readers and writers using atomic variables.

Readers-writer Lock

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

Parallel Programming in Scala: Computing p-norm

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

Scala Parallel Collections: Basics and Best Practices

Covers Scala parallel collections, writing parallelism-agnostic code, converting collections, set intersection, side-effect operations, and concurrent modifications.

Sequential consistency: Basic Concepts

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

Parallel Programming: Splitters and Combiners

Covers Splitters and Combiners in parallel programming using Scala, explaining how to implement key methods efficiently.

Concurrent Stack: Implementation

Delves into the implementation of a concurrent stack and the use of atomic references.

Concurrent Stack: Implementation

Explores the implementation of a concurrent stack data structure and how push and pop operations work concurrently.

Concurrent Stack: Implementation

Explains the reference implementation for a concurrent stack and the importance of handling concurrency issues.

Concurrency: Executors and Mutual Exclusion

Explores executors as efficient thread alternatives and delves into mutual exclusion properties in Scala and JVM.

Synchronization Primitives

Explores the design of synchronization primitives and concurrent data structures using atomic instructions.

Memory Models: Visibility and Semantics

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

Java Memory Model

Covers synchronized semantics in Java, comparing it to the volatile keyword.

Testing Actor Systems

Explores testing actor systems, including verifying observable effects and interacting with parent actors.

The Actor Model: Principles of Reactive Programming

Introduces the Actor Model, explaining actors' identity, behavior, and asynchronous message passing.

Benchmarking Parallel Programs

Covers testing, benchmarking, performance factors, measurement methodologies, ScalaMeter, JVM warmup, and configuration in parallel programming.

Concurrency: Volatile

Explores volatile variables in Java for concurrent programming and synchronization importance.

Conc-Tree Combiners: Parallel Programming in Scala

Explores Conc-Tree Combiners for parallel programming in Scala, covering buffer operations, chunk nodes, and combining methods.

Conc-Trees: Parallel Programming in Scala

Covers the implementation of Conc-Trees in Scala for parallel programming.