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

Lecture

Concurrency Primitives and Pitfalls

Description

This lecture covers concurrency primitives and programming pitfalls in operating systems. It discusses the importance of threads for data sharing and exploiting multiple CPUs, as well as the challenges of uncontrolled thread scheduling leading to data races. The lecture explains mutual exclusion through locks and hardware atomic instructions like Test-and-Set and Compare-and-Swap. It delves into the use of condition variables and semaphores for conditional waiting, signaling, and avoiding concurrency bugs. The examples provided illustrate the implementation of condition variables and semaphores in producer/consumer scenarios. The lecture also addresses common bugs in concurrent programs such as atomicity violations, order violations, and deadlocks.

This video is available exclusively on Mediaspace for a restricted audience. Please log in to MediaSpace to access it if you have the necessary permissions.

Watch on Mediaspace

Official source

Ontological neighbourhood

Computer engineering

High-performance computing: Parallel computing

Related concepts (32)

Thread (computing)

In computer science, a thread of execution is the smallest sequence of programmed instructions that can be managed independently by a scheduler, which is typically a part of the operating system. The implementation of threads and processes differs between operating systems. In Modern Operating Systems, Tanenbaum shows that many distinct models of process organization are possible. In many cases, a thread is a component of a process.

Semaphore (programming)

In computer science, a semaphore is a variable or abstract data type used to control access to a common resource by multiple threads and avoid critical section problems in a concurrent system such as a multitasking operating system. Semaphores are a type of synchronization primitive. A trivial semaphore is a plain variable that is changed (for example, incremented or decremented, or toggled) depending on programmer-defined conditions.

Real-time operating system

A real-time operating system (RTOS) is an operating system (OS) for real-time computing applications that processes data and events that have critically defined time constraints. An RTOS is distinct from a time-sharing operating system, such as Unix, which manages the sharing of system resources with a scheduler, data buffers, or fixed task prioritization in a multitasking or multiprogramming environment. Processing time requirements need to be fully understood and bound rather than just kept as a minimum.

Lock (computer science)

In computer science, a lock or mutex (from mutual exclusion) is a synchronization primitive: a mechanism that enforces limits on access to a resource when there are many threads of execution. A lock is designed to enforce a mutual exclusion concurrency control policy, and with a variety of possible methods there exists multiple unique implementations for different applications. Generally, locks are advisory locks, where each thread cooperates by acquiring the lock before accessing the corresponding data.

Concurrent computing

Concurrent computing is a form of computing in which several computations are executed concurrently—during overlapping time periods—instead of sequentially—with one completing before the next starts. This is a property of a system—whether a program, computer, or a network—where there is a separate execution point or "thread of control" for each process. A concurrent system is one where a computation can advance without waiting for all other computations to complete. Concurrent computing is a form of modular programming.

Related lectures (33)

Monitors: Synchronization and Cooperation

Explores monitors as a synchronization construct providing mutual exclusion and cooperation among threads, with examples like the one-place buffer.

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.

Concurrency Basics: Threads and Synchronization

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

Dining philosopher problem

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

MicroC/OS-II: Real-Time Kernel Overview