Parallel Programming With Microsoft Visual C++® · Design Patterns for Decomposition and Coordination on Multicore Architectures by Campbell, Colin -- Read -- Imperial Library of Trantor

Index

Parallel Programming with Microsoft Visual C++®: Design Patterns for Decomposition and Coordination on Multicore Architectures

Foreword Preface

Who This Book Is For Why This Book Is Pertinent Now What You Need to Use the Code How to Use This Book

Introduction Parallelism with Control Dependencies Only Parallelism with Control and Data Dependencies Dynamic Task Parallelism and Pipelines Supporting Material

What Is Not Covered Goals

Acknowledgments 1. Introduction

The Importance of Potential Parallelism Decomposition, Coordination, and Scalable Sharing

Understanding Tasks Coordinating Tasks Scalable Sharing of Data Design Approaches

Selecting the Right Pattern A Word about Terminology The Limits of Parallelism A Few Tips Exercises For More Information

2. Parallel Loops

The Basics

Parallel for Loops Parallel_for_Each What to Expect

An Example

Sequential Credit Review Example Credit Review Example Using parallel_for_each Performance Comparison

Variations

Breaking out of Loops Early Exception Handling Special Handling of Small Loop Bodies Controlling the Degree of Parallelism

Anti-Patterns

Hidden Loop Body Dependencies Small Loop Bodies with Few Iterations Duplicates in the Input Enumeration Scheduling Interactions with Cooperative Blocking

Related Patterns Exercises Further Reading

3. Parallel Tasks

The Basics An Example Variations

Coordinating Tasks with Cooperative Blocking Canceling a Task Group Handling Exceptions Speculative Execution

Anti-Patterns

Variables Captured by Closures Unintended Propagation of Cancellation Requests The Cost of Synchronization

Design Notes

Task Group Calling Conventions Tasks and Threads How Tasks Are Scheduled Structured Task Groups and Task Handles Lightweight Tasks

Exercises Further Reading

4. Parallel Aggregation

The Basics An Example Variations

Considerations for Small Loop Bodies Other Uses for Combinable Objects

Design Notes Related Patterns Exercises Further Reading

5. Futures

The Basics

Futures

Example: The Adatum Financial Dashboard

The Business Objects The Analysis Engine

Variations

Canceling Futures Removing Bottlenecks Modifying the Graph at Run Time

Design Notes

Decomposition into Futures Functional Style

Related Patterns

Pipeline Pattern Master/Worker Pattern Dynamic Task Parallelism Pattern Discrete Event Pattern

Exercises

6. Dynamic Task Parallelism

The Basics An Example Variations

Parallel While-Not-Empty Adding Tasks to a Pending Wait Context

Exercises Further Reading

7. Pipelines

Types of Messaging Blocks The Basics An Example

Sequential Image Processing The Image Pipeline Performance Characteristics

Variations

Asynchronous Pipelines Canceling a Pipeline Handling Pipeline Exceptions Load Balancing Using Multiple Producers Pipelines and Streams

Anti-Patterns

Copying Large Amounts of Data between Pipeline Stages Pipeline Stages that Are Too Small Forgetting to Use Message Passing for Isolation Infinite Waits Unbounded Queue Growth More Information

Design Notes Related Patterns Exercises Further Reading

A. The Task Scheduler and Resource Manager

Resource Manager

Why It’s Needed How Resource Management Works Dynamic Resource Management Oversubscribing Cores Querying the Environment

Kinds of Tasks

Lightweight Tasks Tasks Created Using PPL

Task Schedulers

Managing Task Schedulers

Creating and Attaching a Task Scheduler Detaching a Task Scheduler Destroying a Task Scheduler Scenarios for Using Multiple Task Schedulers Implementing a Custom Scheduling Component

The Scheduling Algorithm

Schedule Groups Adding Tasks Running Tasks Enhanced Locality Mode Forward Progress Mode Task Execution Order Tasks That Are Run Inline

Using Contexts to Communicate with the Scheduler

Debugging Information Querying for Cancellation Interface to Cooperative Blocking Waiting The Caching Suballocator Long-Running I/O Tasks

Setting Scheduler Policy

Anti-Patterns

Multiple Resource Managers Resource Management Overhead Unintentional Oversubscription from Inlined Tasks Deadlock from Thread Starvation Ignored Process Affinity Mask

References

B. Debugging and Profiling Parallel Applications

The Parallel Tasks and Parallel Stacks Windows Breakpoints and Memory Allocation The Concurrency Visualizer

Scenario Markers

Visual Patterns

Oversubscription Lock Contention and Serialization Load Imbalance