add deprecation notice

Author: TylerMSFT

docs/parallel/amp/cpp-amp-cpp-accelerated-massive-parallelism.md

@@ -3,12 +3,15 @@ description: "Learn more about: C++ AMP (C++ Accelerated Massive Parallelism)"
 title: "C++ AMP (C++ Accelerated Massive Parallelism)"
 ms.date: "11/04/2016"
 helpviewer_keywords: ["C++ AMP (see C++ Accelerated Massive Parallelism)", "C++ Accelerated Massive Parallelism, getting started"]
-ms.assetid: e27824cb-3167-409b-8c3f-a0e476d8f349
 ---
 # C++ AMP (C++ Accelerated Massive Parallelism)
 
 C++ AMP (C++ Accelerated Massive Parallelism) accelerates the execution of your C++ code by taking advantage of the data-parallel hardware that's commonly present as a graphics processing unit (GPU) on a discrete graphics card. The C++ AMP programming model includes support for multidimensional arrays, indexing, memory transfer, and tiling. It also includes 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.
 
+> [!NOTE]
+> C++ AMP headers are deprecated starting with Visual Studio 2022 version 17.0.
+> Including any AMP headers will generate build errors. Define `_SILENCE_AMP_DEPRECATION_WARNINGS` before including any AMP headers to silence the warnings.
+
 ## Related Topics
 
 |Title|Description|

docs/parallel/amp/cpp-amp-overview.md

@@ -3,12 +3,11 @@ description: "Learn more about: C++ AMP Overview"
 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"]
-ms.assetid: 9e593b06-6e3c-43e9-8bae-6d89efdd39fc
 ---
 # C++ AMP Overview
 
 > [!NOTE]
-> C++ AMP headers are deprecated, starting with Visual Studio 2022 version 17.0.
+> C++ AMP headers are deprecated starting with Visual Studio 2022 version 17.0.
 > Including any AMP headers will generate build errors. Define `_SILENCE_AMP_DEPRECATION_WARNINGS` before including any AMP headers to silence the warnings.
 
 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.
@@ -17,7 +16,7 @@ C++ Accelerated Massive Parallelism (C++ AMP) accelerates execution of C++ code
 
 - Windows 7 or later
 
-- Windows Server 2008 R2 or later
+- Windows Server 2008 R2 through Visual Studio 2019.
 
 - DirectX 11 Feature Level 11.0 or later hardware
 

docs/parallel/amp/graphics-cpp-amp.md

@@ -2,18 +2,21 @@
 description: "Learn more about: Graphics (C++ AMP)"
 title: "Graphics (C++ AMP)"
 ms.date: "11/04/2016"
-ms.assetid: 190a98a4-5f7d-442e-866b-b374ca74c16f
 ---
 # Graphics (C++ AMP)
 
-C++ AMP contains several APIs in the [Concurrency::graphics](../../parallel/amp/reference/concurrency-graphics-namespace.md) namespace that you can use to access the texture support on GPUs. Some common scenarios are:
+C++ AMP contains several APIs in the [`Concurrency::graphics`](../../parallel/amp/reference/concurrency-graphics-namespace.md) namespace that you can use to access the texture support on GPUs. Some common scenarios are:
 
-- You can use the [texture](../../parallel/amp/reference/texture-class.md) class as a data container for computation and exploit the *spatial locality* of the texture cache and layouts of GPU hardware. Spatial locality is the property of data elements being physically close to each other.
+- You can use the [`texture`](../../parallel/amp/reference/texture-class.md) class as a data container for computation and exploit the *spatial locality* of the texture cache and layouts of GPU hardware. Spatial locality is the property of data elements being physically close to each other.
 
 - 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.
 
+> [!NOTE]
+> C++ AMP headers are deprecated starting with Visual Studio 2022 version 17.0.
+> Including any AMP headers will generate build errors. Define `_SILENCE_AMP_DEPRECATION_WARNINGS` before including any AMP headers to silence the warnings.
+
 ## The norm and unorm Types
 
 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.
@@ -56,7 +59,7 @@ The Short Vector Library supports the `vector_type.identifier` accessor construc
 
 ## Texture Classes
 
-Many GPUs have hardware and caches that are optimized to fetch pixels and texels and to render images and textures. The [texture\<T,N>](../../parallel/amp/reference/texture-class.md) class, which is a container class for texel objects, exposes the texture functionality of these GPUs. A texel can be:
+Many GPUs have hardware and caches that are optimized to fetch pixels and texels and to render images and textures. The [`texture<T,N>`](../../parallel/amp/reference/texture-class.md) class, which is a container class for texel objects, exposes the texture functionality of these GPUs. A texel can be:
 
 - An **`int`**, `uint`, **`float`**, **`double`**, `norm`, or `unorm` scalar.
 

docs/parallel/amp/using-accelerator-and-accelerator-view-objects.md

@@ -2,19 +2,22 @@
 description: "Learn more about: Using accelerator and accelerator_view Objects"
 title: "Using accelerator and accelerator_view Objects"
 ms.date: "11/04/2016"
-ms.assetid: 18f0dc66-8236-4420-9f46-1a14f2c3fba1
 ---
 # Using accelerator and accelerator_view Objects
 
 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.
 
+> [!NOTE]
+> C++ AMP headers are deprecated starting with Visual Studio 2022 version 17.0.
+> Including any AMP headers will generate build errors. Define `_SILENCE_AMP_DEPRECATION_WARNINGS` before including any AMP headers to silence the warnings.
+
 ## Using the Default Accelerator
 
 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.
 
-2. Otherwise, the accelerator that's specified by the CPPAMP_DEFAULT_ACCELERATOR environment variable, if it's set.
+2. Otherwise, the accelerator that's specified by the `CPPAMP_DEFAULT_ACCELERATOR` environment variable, if it's set.
 
 3. Otherwise, a non-emulated device.
 

docs/parallel/amp/using-cpp-amp-in-windows-store-apps.md

@@ -2,12 +2,15 @@
 description: "Learn more about: Using C++ AMP in UWP Apps"
 title: "Using C++ AMP in UWP Apps"
 ms.date: "11/04/2016"
-ms.assetid: 85577298-2c28-4209-9470-eb21048615db
 ---
 # Using C++ AMP in UWP Apps
 
 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.
 
+> [!NOTE]
+> C++ AMP headers are deprecated starting with Visual Studio 2022 version 17.0.
+> Including any AMP headers will generate build errors. Define `_SILENCE_AMP_DEPRECATION_WARNINGS` before including any AMP headers to silence the warnings.
+
 ## Performance considerations
 
 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.

docs/parallel/amp/using-lambdas-function-objects-and-restricted-functions.md

@@ -2,11 +2,10 @@
 description: "Learn more about: Using Lambdas, Function Objects, and Restricted Functions"
 title: "Using Lambdas, Function Objects, and Restricted Functions"
 ms.date: "11/04/2016"
-ms.assetid: 25346cc9-869d-4ada-aad3-e2228cad3d6c
 ---
 # Using Lambdas, Function Objects, and Restricted Functions
 
-The C++ AMP code that you want to run on the accelerator is specified as an argument in a call to the [parallel_for_each](reference/concurrency-namespace-functions-amp.md#parallel_for_each) method. You can provide either a lambda expression or a function object (functor) as that argument. Additionally, the lambda expression or function object can call a C++ AMP-restricted function. This topic uses an array addition algorithm to demonstrate lambdas, function objects, and restricted functions. The following example shows the algorithm without C++ AMP code. Two 1-dimensional arrays of equal length are created. The corresponding integer elements are added and stored in a third 1-dimensional array. C++ AMP is not used.
+The C++ AMP code that you want to run on the accelerator is specified as an argument in a call to the [`parallel_for_each`](reference/concurrency-namespace-functions-amp.md#parallel_for_each) method. You can provide either a lambda expression or a function object (functor) as that argument. Additionally, the lambda expression or function object can call a C++ AMP-restricted function. This topic uses an array addition algorithm to demonstrate lambdas, function objects, and restricted functions. The following example shows the algorithm without C++ AMP code. Two 1-dimensional arrays of equal length are created. The corresponding integer elements are added and stored in a third 1-dimensional array. C++ AMP is not used.
 
 ```cpp
 void CpuMethod() {

docs/parallel/amp/using-tiles.md

@@ -2,7 +2,6 @@
 description: "Learn more about: Using Tiles"
 title: "Using Tiles"
 ms.date: "11/19/2018"
-ms.assetid: acb86a86-2b7f-43f1-8fcf-bcc79b21d9a8
 ---
 # Using Tiles
 
@@ -20,6 +19,10 @@ To take advantage of tiling, your algorithm must partition the compute domain in
 
 ## Example of Global, Tile, and Local Indices
 
+> [!NOTE]
+> C++ AMP headers are deprecated starting with Visual Studio 2022 version 17.0.
+> Including any AMP headers will generate build errors. Define `_SILENCE_AMP_DEPRECATION_WARNINGS` before including any AMP headers to silence the warnings.
+
 The following diagram represents an 8x9 matrix of data that is arranged in 2x3 tiles.
 
 ![Diagram of an 8 by 9 matrix divided into 2 by 3 tiles.](../../parallel/amp/media/usingtilesmatrix.png)

docs/parallel/amp/walkthrough-debugging-a-cpp-amp-application.md

@@ -9,25 +9,22 @@ helpviewer_keywords: ["debugging, C++ Accelerated Massive Parallelism", "C++ AMP
 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.
 
 ## Prerequisites
 
 Before you start this walkthrough:
 
-- Read [C++ AMP Overview](../../parallel/amp/cpp-amp-overview.md).
+> [!NOTE]
+> C++ AMP headers are deprecated starting with Visual Studio 2022 version 17.0.
+> Including any AMP headers will generate build errors. Define `_SILENCE_AMP_DEPRECATION_WARNINGS` before including any AMP headers to silence the warnings.
 
+- Read [C++ AMP Overview](../../parallel/amp/cpp-amp-overview.md).
 - 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)]

docs/parallel/amp/walkthrough-matrix-multiplication.md

@@ -2,7 +2,6 @@
 description: "Learn more about: Walkthrough: Matrix Multiplication"
 title: "Walkthrough: Matrix Multiplication"
 ms.date: 10/27/2021
-ms.assetid: 61172e8b-da71-4200-a462-ff3a908ab0cf
 ---
 # Walkthrough: Matrix Multiplication
 
@@ -13,11 +12,13 @@ This step-by-step walkthrough demonstrates how to use C++ AMP to accelerate the
 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.
 
+> [!NOTE]
+> C++ AMP headers are deprecated starting with Visual Studio 2022 version 17.0.
+> Including any AMP headers will generate build errors. Define `_SILENCE_AMP_DEPRECATION_WARNINGS` before including any AMP headers to silence the warnings.
+
 ### To create the project
 
 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.