Part B (ADVANCE) Multithreading Design Patterns ( pthreads )

Course Curriculum

Chapter 1: What this Course is all about ?

Lecture 1: Agenda and Prerequisites

Lecture 2: Code Access for this Course

Chapter 2: Thread Management

Lecture 1: Getting Started

Lecture 2: Getting Started with threadlib Library

Chapter 3: Thread Pausing and Resuming

Lecture 1: Requirements

Lecture 2: APIs

Lecture 3: Data Structure Enhancements

Lecture 4: APIs Implementation

Chapter 4: Go through Appendix A : Glthreads – Glue Based LinkedList

Lecture 1: Vacation Time !

Chapter 5: Thread Pools/Work Crew Thread Model

Lecture 1: Introduction to Thread Pools

Lecture 2: Thread Pool Benefits

Lecture 3: Thread Pool Designing

Lecture 4: Thread Pool Data Structures and APIs

Lecture 5: Thread Pool Implementation – Getting started

Lecture 6: Thread Pool Implementation – Part 1

Lecture 7: Thread Pool Implementation – Part 2

Lecture 8: Thread Pool Implementation – Part 3

Lecture 9: Thread Pool Demo 1

Lecture 10: Step 7 – Caller Thread blocking Design

Lecture 11: Step 7 – Caller Thread blocking Implementation

Chapter 6: Thread Barriers

Lecture 1: Thread Barrier : Introduction

Lecture 2: Thread Barrier Functioning

Lecture 3: Thread Barrier Data Structures

Lecture 4: Thread Barrier APIs

Lecture 5: Thread Barrier Wait ( ) Implementation

Lecture 6: Final Demo

Chapter 7: Wait Queues

Lecture 1: Introduction and Use Case Examples

Lecture 2: How to use WQ in Multithreaded Appln Code

Lecture 3: WQ Condition Fn Implementation

Lecture 4: WQ Data Structure and APIs

Lecture 5: WQ_test_and_wait API Implementation

Lecture 6: Comparing test_and_wait( ) API with Standard Steps

Lecture 7: Lets Code up Wait Queues

Lecture 8: Demo Example using Wait Queues

Lecture 9: Traffic Light Data Structures

Lecture 10: Template Programs to start with

Lecture 11: Solution Discussion

Chapter 8: Recursive Mutexes

Lecture 1: What is Recursive Mutex ?

Lecture 2: Practical Scenario of Using Reclusive Locks

Lecture 3: Assignment – Rec Mutex Internal Implementation

Lecture 4: Recursive Mutex – Data Structure Definition

Lecture 5: rec_mutex_lock() API Implementation

Lecture 6: rec_mutex_unlock() API Implementation

Chapter 9: Read/Write Locks

Lecture 1: What in this Section ?

Lecture 2: Understanding Read/Write Locks

Lecture 3: POSIX APIs

Lecture 4: Demo Example Program

Lecture 5: RW Lock Self Implementation – Begin

Lecture 6: Custom RW LOCK Data Structure

Lecture 7: Read Lock API Implementation

Lecture 8: Write Lock API Implementation

Lecture 9: RW lock Unlock API Implementation

Chapter 10: Monitors

Lecture 1: Monitors – Introduction

Lecture 2: Converting RW Locks into Monitor

Lecture 3: Adding Customizations 1

Lecture 4: Adding Customizations 2 & 3

Lecture 5: Adding Customization 4

Lecture 6: Adding Customization 5 ( Last )

Lecture 7: Testing our Custom Monitor

Chapter 11: Bridge Problem

Lecture 1: Bridge Crossing Problem

Lecture 2: Approaching the Solution

Lecture 3: Solving Bridge Problem Using Monitors

Lecture 4: Monitor Designing Guidelines

Chapter 12: Appendix A : Glthreads – Glue Based LinkedList

Lecture 1: Introduction

Lecture 2: GLThread Definition

Lecture 3: Pictorial Difference

Lecture 4: Structure Field Offset

Lecture 5: Node Insertion

Lecture 6: Iteration

Lecture 7: Node Removal

Lecture 8: Code Walk – Demo

Lecture 9: Traditional Linked List Problems

Lecture 10: GLThread Benefits

Chapter 13: Appendix B – Thread Cancellation – Problem of Invariants and Resource Leaking

Lecture 1: Thread Resource Leaking Problem

Lecture 2: Data Structure Corruption – Invariants

Chapter 14: Bonus Lecture

Lecture 1: Candies for you !