Merge pull request #4758 from MicrosoftDocs/main

1/24 AM Publish

Author: huypub

docs/build/arm64-exception-handling.md

@@ -218,11 +218,11 @@ This data is broken into four sections:
 
       2. If **E** is 1, then this field specifies the index of the first unwind code that describes the one and only epilog.
 
-   f. **Code Words** is a 5-bit field that specifies the number of 32-bit words needed to contain all of the unwind codes in section 3. If more than 31 words are required (that is, if there are more than 124 unwind code bytes), then this field must be 0 to indicate that an extension word is required.
+   f. **Code Words** is a 5-bit field that specifies the number of 32-bit words needed to contain all of the unwind codes in section 3. If more than 31 words (that is, 124 unwind codes) are required, then this field must be 0 to indicate that an extension word is required.
 
    g. **Extended Epilog Count** and **Extended Code Words** are 16-bit and 8-bit fields, respectively. They provide more space for encoding an unusually large number of epilogs, or an unusually large number of unwind code words. The extension word that contains these fields is only present if both the **Epilog Count** and **Code Words** fields in the first header word are 0.
 
-1. If **Epilog Count** isn't zero, a list of information about epilog scopes, packed one to a word,  comes after the header and optional extended header. They're stored in order of increasing starting offset. Each scope contains the following bits:
+1. If the count of epilogs isn't zero, a list of information about epilog scopes, packed one to a word, comes after the header and optional extended header. They're stored in order of increasing starting offset. Each scope contains the following bits:
 
    a. **Epilog Start Offset** is an 18-bit field that has the offset in bytes, divided by 4, of the epilog relative to the start of the function.
 

docs/c-runtime-library/format-specification-syntax-printf-and-wprintf-functions.md

@@ -65,7 +65,7 @@ Integer types such as `short`, `int`, `long`, `long long`, and their `unsigned`
 | **`p`** | Pointer type | Display the argument as an address in hexadecimal digits. |
 | **`s`** | String | When used with `printf` functions, specifies a single-byte or multi-byte character string; when used with `wprintf` functions, specifies a wide-character string. Characters are displayed up to the first null character or until the *precision* value is reached. |
 | **`S`** | String | When used with `printf` functions, specifies a wide-character string; when used with `wprintf` functions, specifies a single-byte or multi-byte character string. Characters are displayed up to the first null character or until the *precision* value is reached. |
-| **`Z`** | `ANSI_STRING` or `UNICODE_STRING` structure | When the address of an [`ANSI_STRING`](/windows/win32/api/ntdef/ns-ntdef-string) or [`UNICODE_STRING`](/windows/win32/api/ntdef/ns-ntdef-_unicode_string) structure is passed as the argument, display the string contained in the buffer pointed to by the `Buffer` field of the structure. Use a *size* modifier prefix of **`w`** to specify a `UNICODE_STRING` argument—for example, `%wZ`. The `Length` field of the structure must be set to the length, in bytes, of the string. The `MaximumLength` field of the structure must be set to the length, in bytes, of the buffer.<br /><br />Typically, the **`Z`** type character is used only in driver debugging functions that use a conversion specification, such as `dbgPrint` and `kdPrint`. |
+| **`Z`** | `ANSI_STRING` or `UNICODE_STRING` structure | **VS 2013 and earlier** <br /> When the address of an [`ANSI_STRING`](/windows/win32/api/ntdef/ns-ntdef-string) or [`UNICODE_STRING`](/windows/win32/api/ntdef/ns-ntdef-_unicode_string) structure is passed as the argument, display the string contained in the buffer pointed to by the `Buffer` field of the structure. Use a *size* modifier prefix of **`w`** to specify a `UNICODE_STRING` argument—for example, `%wZ`. The `Length` field of the structure must be set to the length, in bytes, of the string. The `MaximumLength` field of the structure must be set to the length, in bytes, of the buffer.<br /><br /> **Universal C Runtime (UCRT)**<br />There is a known issue in the UCRT that is currently maintained for compatibility. Like the **`S`** specifier, the **`Z`** specifier without a size modifier prefix refers to a `UNICODE_STRING` when using a narrow printing function (like `printf`) and an `ANSI_STRING` when using a wide printing function (like `wprintf`).<br /> Instead of **`Z`**, use **`hZ`** to specify an `ANSI_STRING`. **`wZ`** (or **`lZ`**) can still be used to specify a `UNICODE_STRING`. <br /><br />Typically, the **`Z`** type character is used only in driver debugging functions that use a conversion specification, such as `dbgPrint` and `kdPrint`. |
 
 In Visual Studio 2015 and later versions, if the argument that corresponds to a floating-point conversion specifier (**`a`**, **`A`**, **`e`**, **`E`**, **`f`**, **`F`**, **`g`**, **`G`**) is infinite, indefinite, or NaN, the formatted output conforms to the C99 standard. This table lists the formatted output:
 

docs/intrinsics/bitscanforward-bitscanforward64.md

@@ -39,7 +39,7 @@ unsigned char _BitScanForward64(
 
 ## Remarks
 
-If a set bit is found, the bit position of the first set bit found is returned in the first parameter. If no set bit is found, 0 is returned; otherwise, 1 is returned.
+If a set bit is found, the bit position of the first set bit is written to the address specified in the first parameter and the function returns 1. If no bit is found, the function returns 0 and the value written to the address in the first parameter is undefined.
 
 ## Requirements
 

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)]