Books & Videos

Table of Contents

Chapter: Getting Started with Parallel Computing and Python

The Course Overview

06m 12s

The Parallel Computing Memory Architecture

06m 58s

Memory Organization

05m 30s

Memory Organization (Continued)

04m 13s

Parallel Programming Models

06m 18s

Designing a Parallel Program

05m 19s

Evaluating the Performance of a Parallel Program

06m 19s

Introducing Python

02m 25s

Working with Processes in Python

03m 35s

Chapter: Thread-Based Parallelism

Defining a Thread

03m 19s

Determining the Current Thread

01m 4s

Using a Thread in a Subclass

01m 57s

Thread Synchronization with Lock

05m 22s

Thread Synchronization with RLock

01m 45s

Thread Synchronization with Semaphores

04m 50s

Thread Synchronization with a Condition

02m 24s

Thread Synchronization with an Event

01m 49s

Using the "with" Statement

02m 1s

Thread Communication Using a Queue

03m 6s

Evaluating the Performance of Multithread Applications

04m 36s

Chapter: Process-Based Parallelism

Spawning a Process

02m 47s

Naming a Process

01m 13s

Running a Process in the Background

01m 16s

Killing a Process

01m 27s

Using a Process in a Subclass

01m 21s

Exchanging Objects between Processes

02m 57s

Synchronizing Processes

02m 42s

Managing a State between Processes

01m 26s

Using a Process Pool

02m 21s

Using the mpi4py Python Module

04m 11s

Point-to-Point Communication

02m 59s

Avoiding Deadlock Problems

03m 6s

Using Broadcast for Collective Communication

03m 10s

Using Scatter for Collective Communication

02m 8s

Using Gather for Collective Communication

01m 39s

Using Alltoall for Collective Communication

03m 5s

The Reduction Operation

02m 53s

Optimizing the Communication

03m 28s

Chapter: Asynchronous Programming

Using the concurrent.futures Python Modules

05m 21s

Event Loop Management with Asyncio

04m 20s

Handling Coroutines with Asyncio

04m 6s

Manipulating a Task with Asyncio

02m 22s

Dealing with Asyncio and Futures

03m 4s

Chapter: Distributed Python

Using Celery to Distribute Tasks

03m 27s

Creating a Task with Celery

03m 8s

Scientific Computing with SCOOP

04m 54s

Handling Map Functions with SCOOP

04m 3s

Remote Method Invocation with Pyro4

05m 27s

Chaining Objects with Pyro4

04m 1s

Developing a Client-Server Application with Pyro4

04m 18s

Communicating Sequential Processes with PyCSP

07m 2s

A Remote Procedure Call with RPyC

03m 39s

Chapter: GPU Programming with Python

Using the PyCUDA Module

07m 32s

Building a PyCUDA Application

07m 32s

Understanding the PyCUDA Memory Model with Matrix Manipulation

05m 36s

Kernel Invocations with GPU Array

02m 23s

Evaluating Element-Wise Expressions with PyCUDA

03m 20s

The MapReduce Operation with PyCUDA

03m 42s

GPU Programming with NumbaPro

04m 47s

Using GPU-Accelerated Libraries with NumbaPro

05m 26s

Using the PyOpenCL Module

04m 3s

Building a PyOpenCL Application

04m 58s

Evaluating Element-Wise Expressions with PyOpenCl

03m 10s

Testing Your GPU Application with PyOpenCL

04m 13s