Books & Videos

Table of Contents

  1. Chapter 1 Why Threading Building Blocks?

    1. Overview

    2. Benefits

  2. Chapter 2 Thinking Parallel

    1. Elements of Thinking Parallel

    2. Decomposition

    3. Scaling and Speedup

    4. What Is a Thread?

    5. Mutual Exclusion and Locks

    6. Correctness

    7. Abstraction

    8. Patterns

    9. Intuition

  3. Chapter 3 Basic Algorithms

    1. Initializing and Terminating the Library

    2. Loop Parallelization

    3. Recursive Range Specifications

    4. Recursive Range Specifications

    5. Summary of Loops

  4. Chapter 4 Advanced Algorithms

    1. Parallel Algorithms for Streams

  5. Chapter 5 Containers

    1. concurrent_queue

    2. concurrent_vector

    3. concurrent_vector

    4. concurrent_hash_map

  6. Chapter 6 Scalable Memory Allocation

    1. Limitations

    2. Problems in Memory Allocation

    3. Memory Allocators

    4. Replacing malloc, new, and delete

  7. Chapter 7 Mutual Exclusion

    1. When to Use Mutual Exclusion

    2. Mutexes

    3. Mutexes

    4. Atomic Operations

  8. Chapter 8 Timing

  9. Chapter 9 Task Scheduler

    1. When Task-Based Programming Is Inappropriate

    2. Much Better Than Raw Native Threads

    3. Initializing the Library Is Your Job

    4. Example Program for Fibonacci Numbers

    5. Task Scheduling Overview

    6. How Task Scheduling Works

    7. Recommended Task Recurrence Patterns

    8. Making Best Use of the Scheduler

    9. Task Scheduler Interfaces

    10. Task Scheduler Summary

  10. Chapter 10 Keys to Success

    1. Key Steps to Success

    2. Relaxed Sequential Execution

    3. Safe Concurrency for Methods and Libraries

    4. Debug Versus Release

    5. For Efficiency’s Sake

    6. Enabling Debugging Features

    7. Mixing with Other Threading Packages

    8. Naming Conventions

  11. Chapter 11 Examples

    1. The Aha! Factor

    2. A Few Other Key Points

    3. parallel_for Examples

    4. The Game of Life

    5. Parallel_reduce Examples

    6. CountStrings: Using concurrent_hash_map

    7. Quicksort: Visualizing Task Stealing

    8. A Better Matrix Multiply (Strassen)

    9. Advanced Task Programming

    10. Packet Processing Pipeline

    11. Memory Allocation

    12. Game Threading Example

    13. Physics Interaction and Update Code

    14. Open Dynamics Engine

  12. Chapter 12 History and Related Projects

    1. Libraries

    2. Languages

    3. Pragmas

    4. Generic Programming

    5. Caches

    6. Costs of Time Slicing

    7. Quick Introduction to Lambda Functions

    8. Further Reading

  1. Colophon