title: "C++ AMP Overview"

ms.date: "11/19/2018"

helpviewer_keywords: ["C++ Accelerated Massive Parallelism, requirements", "C++ Accelerated Massive Parallelism, architecture", "C++ AMP", "C++ Accelerated Massive Parallelism, overview", "C++ Accelerated Massive Parallelism"]

C++ Accelerated Massive Parallelism (C++ AMP) accelerates execution of C++ code by taking advantage of data-parallel hardware such as a graphics processing unit (GPU) on a discrete graphics card. By using C++ AMP, you can code multi-dimensional data algorithms so that execution can be accelerated by using parallelism on heterogeneous hardware. The C++ AMP programming model includes multidimensional arrays, indexing, memory transfer, tiling, and a mathematical function library. You can use C++ AMP language extensions to control how data is moved from the CPU to the GPU and back, so that you can improve performance.

- Windows 7 or later

- DirectX 11 Feature Level 11.0 or later hardware

description: "Learn more about: Graphics (C++ AMP)"

title: "Graphics (C++ AMP)"

ms.date: "11/04/2016"

- The runtime provides efficient interoperability with non-compute shaders. Pixel, vertex, tessellation, and hull shaders frequently consume or produce textures that you can use in your C++ AMP computations.

- The graphics APIs in C++ AMP provide alternative ways to access sub-word packed buffers. Textures that have formats that represent *texels* (texture elements) that are composed of 8-bit or 16-bit scalars allow access to such packed data storage.

The `norm` and `unorm` types are scalar types that limit the range of **`float`** values; this is known as *clamping*. These types can be explicitly constructed from other scalar types. In casting, the value is first cast to **`float`** and then clamped to the respective region that's allowed by `norm [-1.0, 1.0]` or `unorm [0.0, 1.0]`. Casting from +/- infinity returns +/-1. Casting from NaN is undefined. A `norm` can be implicitly constructed from a `unorm` and there is no loss of data. The implicit conversion operator to **`float`** is defined on these types. Binary operators are defined between these types and other built-in scalar types such as **`float`** and **`int`**: `+`, `-`, `*`, `/`, `==`, `!=`, `>`, `<`, `>=`, `<=`. The compound assignment operators are also supported: `+=`, `-=`, `*=`, `/=`. The unary negation operator (`-`) is defined for `norm` types.

- An **`int`**, `uint`, **`float`**, **`double`**, `norm`, or `unorm` scalar.

description: "Learn more about: Using accelerator and accelerator_view Objects"

title: "Using accelerator and accelerator_view Objects"

ms.date: "11/04/2016"

You can use the [accelerator](../../parallel/amp/reference/accelerator-class.md) and [accelerator_view](../../parallel/amp/reference/accelerator-view-class.md) classes to specify the device or emulator to run your C++ AMP code on. A system might have several devices or emulators that differ by amount of memory, shared memory support, debugging support, or double-precision support. C++ Accelerated Massive Parallelism (C++ AMP) provides APIs that you can use to examine the available accelerators, set one as the default, specify multiple accelerator_views for multiple calls to parallel_for_each, and perform special debugging tasks.

The C++ AMP runtime picks a default accelerator, unless you write code to pick a specific one. The runtime chooses the default accelerator as follows:

1. If the app is running in debug mode, an accelerator that supports debugging.

3. Otherwise, a non-emulated device.

description: "Learn more about: Using C++ AMP in UWP Apps"

title: "Using C++ AMP in UWP Apps"

ms.date: "11/04/2016"

You can use C++ AMP (C++ Accelerated Massive Parallelism) in your Universal Windows Platform (UWP) app to perform calculations on the GPU (Graphics Processing Unit) or other computational accelerators. However, C++ AMP doesn't provide APIs for working directly with Windows Runtime types, and the Windows Runtime doesn't provide a wrapper for C++ AMP. When you use Windows Runtime types in your code—including those that you've created yourself—you must convert them to types that are compatible with C++ AMP.

If you're using Visual C++ component extensions C++/CX to create your Universal Windows Platform (UWP) app, we recommend that you use plain-old-data (POD) types together with contiguous storage—for example, `std::vector` or C-style arrays—for data that will be used with C++ AMP. This can help you achieve higher performance than by using non-POD types or Windows Runtime containers because no marshaling has to occur.

description: "Learn more about: Using Lambdas, Function Objects, and Restricted Functions"

title: "Using Lambdas, Function Objects, and Restricted Functions"

ms.date: "11/04/2016"

void CpuMethod() {

description: "Learn more about: Using Tiles"

title: "Using Tiles"

ms.date: "11/19/2018"

The following diagram represents an 8x9 matrix of data that is arranged in 2x3 tiles.


This article demonstrates how to debug an application that uses C++ Accelerated Massive Parallelism (C++ AMP) to take advantage of the graphics processing unit (GPU). It uses a parallel-reduction program that sums up a large array of integers. This walkthrough illustrates the following tasks:

- Launching the GPU debugger.

- Inspecting GPU threads in the GPU Threads window.

- Using the **Parallel Stacks** window to simultaneously observe the call stacks of multiple GPU threads.

- Using the **Parallel Watch** window to inspect values of a single expression across multiple threads at the same time.

- Flagging, freezing, thawing, and grouping GPU threads.

- Executing all the threads of a tile to a specific location in code.

Before you start this walkthrough:

- Make sure that line numbers are displayed in the text editor. For more information, see [How to: Display line numbers in the editor](/visualstudio/ide/reference/how-to-display-line-numbers-in-the-editor).

- Make sure you're running at least Windows 8 or Windows Server 2012 to support debugging on the software emulator.

[!INCLUDE[note_settings_general](../../mfc/includes/note_settings_general_md.md)]

description: "Learn more about: Walkthrough: Matrix Multiplication"

title: "Walkthrough: Matrix Multiplication"

ms.date: 10/27/2021

Before you start:

- Read [C++ AMP Overview](../../parallel/amp/cpp-amp-overview.md).

- Read [Using Tiles](../../parallel/amp/using-tiles.md).

- Make sure that you are running at least Windows 7, or Windows Server 2008 R2.

Instructions for creating a new project vary depending on which version of Visual Studio you have installed. To see the documentation for your preferred version of Visual Studio, use the **Version** selector control. It's found at the top of the table of contents on this page.