Learn your way! Get started

C++ AMP, Part 1: Parallelism and Management

with expert John Stratton

Watch trailer

C++ AMP, Part 1: Parallelism and Management Trailer

Course at a glance

Included in these subscriptions:

  • Dev & IT Pro Video
  • Dev & IT Pro Power Pack
  • Power Pack Plus

Release date Release date 7/29/2013
Level Level Advanced
Runtime Runtime 2h 4m
Platform Platform Major browsers on Windows Major browsers on Windows Major browsers on Mac OSX Major browsers on Mac OSX Mobile Devices Mobile Devices
Closed captioning Closed captioning Included
Transcript Transcript Included
eBooks / courseware eBooks / courseware Included
Hands-on labs Hands-on labs N/A
Sample code Sample code Included
Exams Exams Included

Enterprise Solutions
Enterprise Solutions

Need reporting, custom learning tracks, or SCORM? Learn More

Course description

The course will start with an overview of how you can analyze code in terms of kinds of work, and identify where C++AMP might be useful. We’ll talk about why C++AMP is useful for taking full advantage of modern computing systems, and how you can begin to use C++AMP constructs in your existing code. We’ll also compare C++AMP to other popular heterogeneous computing models, so that you can see the tradeoffs associated with each. Then we’re going to cover the abstractions available in C++AMP for managing the accelerator devices themselves. Once an application has a handle on the device it wants to use for computation, it will also need to express data collections and data indexes, possibly in multiple dimensions.


This course assumes that you have a good understanding of core C++ concepts, included classes, objects, containers, and iterators. You should also be familiar with Visual Studio 2012 for Visual C++ development, including compilation, testing, and debugging. Although not required or expected, you may get more out of some parts of the course if you are familiar with multithreaded programming, Visual Studio 2012’s debugging capabilities for multiple threads, and basic computer architecture concepts.

Meet the expert

John Stratton John Stratton, Ph.D., is a senior architect at Multicoreware Inc. and a visiting lecturer at the University of Illinois at Urbana-Champaign. John has been at the forefront of research and education in heterogeneous computing, reaching hundreds of students through the Virtual School of Computational Science and Engineering’s courses on heterogeneous computing and optimization for scientific applications. John writes papers and articles for leading academic conferences and journals as well as broad-reaching publications such as IEEE Computer. He is also an active participant and presenter at several industry and technology groups and events across the country.

Course outline


Code Parallelism (13:01)
  • Introduction (00:34)
  • Types of Work: Sequential (01:42)
  • Types of Work: Task Parallel (02:47)
  • Types of Work: Data Parallel (02:28)
  • Demo: Types of Work (04:59)
  • Summary (00:29)
AMP Data Parallelism (13:32)
  • Introduction (00:30)
  • System Architecture Model (02:09)
  • Basic C++ AMP Usage (01:50)
  • Demo: C++ AMP and Features (06:06)
  • Task vs. Data Parallelism (02:35)
  • Summary (00:20)
Heterogeneous Computing (13:09)
  • Introduction (00:29)
  • Heterogeneous Computing Systems (03:27)
  • Benefits and Uses of Parallelism (01:57)
  • What is C++ AMP Good For? (03:53)
  • Demo: Utilizing the GPU (02:32)
  • Summary (00:49)
Alternate Models (19:36)
  • Introduction (00:35)
  • CUDA Overview and Tradeoffs (03:50)
  • Demo: CUDA (05:21)
  • OpenCL Overview and Tradeoffs (03:25)
  • Demo: OpenCL (05:48)
  • Summary (00:33)


Accelerator Management (15:42)
  • Introduction (00:36)
  • Managing Accelerators (02:21)
  • Demo: Accelerators (03:28)
  • Managing Accelerator Contexts (03:51)
  • Demo: Accelerators and C++AMP (04:51)
  • Summary (00:32)
Data Management (24:25)
  • Introduction (00:20)
  • Multidimensional Ranges (01:46)
  • Multidimensional Indexes (02:20)
  • Accelerator Data Management (01:55)
  • Demo: Data Management (04:58)
  • Demo: Effects (05:23)
  • Array Views (03:00)
  • Demo: Array Views (04:05)
  • Summary (00:34)
Accelerator Programs (25:32)
  • Introduction (00:31)
  • Launching Accelerator Programs (04:10)
  • restrict(amp) (07:21)
  • Demo: parallel_for_each (05:32)
  • Demo: restrict(amp) (03:17)
  • Demo: CPU Variables (03:44)
  • Summary (00:54)