Visual C++并行编程指南：AMP与C++AMP详解

需积分: 10 117 浏览量更新于2024-07-17 收藏 6.56MB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

并行编程在Visual C++中的应用提供了强大的性能优化手段，使开发人员能够利用多核处理器的优势来加速代码执行。本指南深入探讨了Microsoft官方文档中关于此主题的内容，涵盖了多个关键概念和技术。 1. **自动并行化和自动向量化**： Visual C++支持自动并行化（Auto-Parallelization），这是一种编译器优化技术，它能够识别可以并行处理的部分代码，并将其分解成可独立执行的任务。同时，自动向量化（Auto-Vectorization）则是将指令集扩展到SIMD（Single Instruction Multiple Data）级别，提升浮点运算效率。这两种特性无需开发者显式编写多线程代码，提高了编程的简洁性和可读性。 2. **加速并行处理（Accelerated Multiprocessing, AMP）**：是一种针对图形处理单元（GPU）设计的并行计算平台，允许开发人员利用GPU的并行计算能力进行大规模并行任务。AMP通过专门的数据类型和API，如`accelerator`和`accelerator_view`，简化了与GPU交互的过程。 3. **C++ AMP（C++ Accelerated Massive Parallelism）**：是一种C++库，专为在GPU上进行高性能计算而设计。它提供了`array`、`array_view`等类，以及`Concurrency::direct3d`命名空间，用于在Windows Universal Platform (UWP) 应用中高效利用图形硬件。 4. **矩阵乘法示例**：文档提供了一个详细的教程，展示了如何使用C++ AMP进行矩阵乘法操作，包括创建`accelerator_view`对象，组织数据块（tiles）以及调试并行应用程序的技巧。 5. **调试工具**：针对C++ AMP应用，有特定的调试方法和工具，如`tile_barrier`和`tiled_index`，帮助开发者追踪并解决并行程序中的问题。 6. **Lambda函数、函数对象和受限函数**：作为现代C++的特性，lambda表达式和函数对象被用于编写简洁的并行算法，而受限函数则限制了哪些代码可以在GPU上运行，确保计算的正确性和性能。 7. **图形相关API**：在C++ AMP中，`Concurrency::direct3d`命名空间提供了与Direct3D图形接口的集成，如`adopt_d3d_access`等函数，用于更高效的图形处理。 8. **类和枚举**：文档详述了一系列关键类（如`accelerator`, `accelerator_view`等）、枚举（如并发控制的枚举类型）以及它们的操作符和常量，为开发者提供了丰富的功能和选项。 9. **异常处理**：对可能出现的错误情况，如内存不足或不支持的功能，文档列出了相应的异常类，如`out_of_memoryClass`和`unsupported_featureClass`，以及如何处理这些异常。 Parallel Programming in Visual C++文档提供了全面的指导，涵盖了从基础概念到高级技术的方方面面，帮助开发人员充分利用并行计算资源，优化C++代码在各种平台上，特别是GPU上的性能表现。通过学习和实践这些技术，开发者能够提升软件的响应速度和能效。

资源详情

资源推荐

See Also
As with all pragma directives, the alternate pragma syntax  __pragma(loop(no_vector))  is also supported.
As with the Auto
-
Parallelizer, you can specify the /Qvec
-
report 
(
Auto
-
Vectorizer Reporting Level
)
 command
-
line
option to report either successfully vectorized loops only
—
/Qvec-report:1
—
or both successfully and
unsuccessfully vectorized loops
—
/Qvec-report:2
)
.
For more information about reason codes and messages, see Vectorizer and Parallelizer Messages.
For an example showing how the vectorizer works in practice, see Project Austin Part 2 of 6: Page Curling
loop
Parallel Programming in Native Code
/Qpar 
(
Auto
-
Parallelizer
)
/Qpar
-
report 
(
Auto
-
Parallelizer Reporting Level
)
/Qvec
-
report 
(
Auto
-
Vectorizer Reporting Level
)
Vectorizer and Parallelizer Messages

C++ AMP Overview

11/20/2018 • 18 minutes to read • Edit Online

System Requirements

Introduction

#include <iostream>

void StandardMethod() {

int aCPP[] = {1, 2, 3, 4, 5};

int bCPP[] = {6, 7, 8, 9, 10};

int sumCPP[5];

for (int idx = 0; idx < 5; idx++)

{

sumCPP[idx] = aCPP[idx] + bCPP[idx];

}

for (int idx = 0; idx < 5; idx++)

{

std::cout << sumCPP[idx] << "\n";

}

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, Windows 8, Windows Server 2008 R2, or Windows Server 2012

DirectX 11 Feature Level 11.0 or later hardware

For debugging on the software emulator, Windows 8 or Windows Server 2012 is required. For debugging

on the hardware, you must install the drivers for your graphics card. For more information, see Debugging

GPU Code.

The following two examples illustrate the primary components of C++ AMP. Assume that you want to add the

corresponding elements of two one

dimensional arrays. For example, you might want to add {1, 2, 3, 4, 5}

and {6, 7, 8, 9, 10} to obtain {7, 9, 11, 13, 15} . Without using C++ AMP, you might write the following

code to add the numbers and display the results.

The important parts of the code are as follows:

Data: The data consists of three arrays. All have the same rank

(

one

)

and length

(

five

)

Iteration: The first for loop provides a mechanism for iterating through the elements in the arrays. The

code that you want to execute to compute the sums is contained in the first for block.

Index: The idx variable accesses the individual elements of the arrays.

#include <amp.h>

#include <iostream>

using namespace concurrency;

const int size = 5;

void CppAmpMethod() {

int aCPP[] = {1, 2, 3, 4, 5};

int bCPP[] = {6, 7, 8, 9, 10};

int sumCPP[size];

// Create C++ AMP objects.

array_view<const int, 1> a(size, aCPP);

array_view<const int, 1> b(size, bCPP);

array_view<int, 1> sum(size, sumCPP);

sum.discard_data();

parallel_for_each(

// Define the compute domain, which is the set of threads that are created.

sum.extent,

// Define the code to run on each thread on the accelerator.

[=](index<1> idx) restrict(amp) {

sum[idx] = a[idx] + b[idx];

}

);

// Print the results. The expected output is "7, 9, 11, 13, 15".

for (int i = 0; i < size; i++) {

std::cout << sum[i] << "\n";

}

Shaping and Indexing Data: index and extent

index Classindex Class

Using C++ AMP, you might write the following code instead.

The same basic elements are present, but C++ AMP constructs are used:

Data: You use C++ arrays to construct three C++ AMP array_view objects. You supply four values to

construct an array_view object: the data values, the rank, the element type, and the length of the

array_view object in each dimension. The rank and type are passed as type parameters. The data and

length are passed as constructor parameters. In this example, the C++ array that is passed to the

constructor is one

dimensional. The rank and length are used to construct the rectangular shape of the data

in the array_view object, and the data values are used to fill the array. The runtime library also includes the

array Class, which has an interface that resembles the array_view class and is discussed later in this article.

Iteration: The parallel_for_each Function

(

C++ AMP

)

provides a mechanism for iterating through the data

elements, or compute domain. In this example, the compute domain is specified by sum.extent . The code

that you want to execute is contained in a lambda expression, or kernel function. The restrict(amp)

indicates that only the subset of the C++ language that C++ AMP can accelerate is used.

Index: The index Class variable, idx , is declared with a rank of one to match the rank of the array_view

object. By using the index, you can access the individual elements of the array_view objects.

You must define the data values and declare the shape of the data before you can run the kernel code. All data is

defined to be an array

(

rectangular

)

, and you can define the array to have any rank

(

number of dimensions

)

. The

data can be any size in any of the dimensions.

The index Class specifies a location in the array or array_view object by encapsulating the offset from the origin

int aCPP[] = {1, 2, 3, 4, 5};

array_view<int, 1> a(5, aCPP);

index<1> idx(2);

std::cout << a[idx] << "\n";

// Output: 3

int aCPP[] = {1, 2, 3, 4, 5, 6};

array_view<int, 2> a(2, 3, aCPP);

index<2> idx(1, 2);

std::cout <<a[idx] << "\n";

// Output: 6

int aCPP[] = {

1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,

1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};

array_view<int, 3> a(2, 3, 4, aCPP);

// Specifies the element at 3, 1, 0.

index<3> idx(0, 1, 3);

std::cout << a[idx] << "\n";

// Output: 8

extent Classextent Class

in each dimension into one object. When you access a location in the array, you pass an index object to the

indexing operator, [] , instead of a list of integer indexes. You can access the elements in each dimension by using

the array::operator

()

Operator or the array_view::operator

()

Operator.

The following example creates a one

dimensional index that specifies the third element in a one

dimensional

array_view object. The index is used to print the third element in the array_view object. The output is 3.

The following example creates a two

dimensional index that specifies the element where the row = 1 and the

column = 2 in a two

dimensional array_view object. The first parameter in the index constructor is the row

component, and the second parameter is the column component. The output is 6.

The following example creates a three

dimensional index that specifies the element where the depth = 0, the row

= 1, and the column = 3 in a three

dimensional array_view object. Notice that the first parameter is the depth

component, the second parameter is the row component, and the third parameter is the column component. The

output is 8.

The extent Class specifies the length of the data in each dimension of the array or array_view object. You can

create an extent and use it to create an array or array_view object. You can also retrieve the extent of an existing

array or array_view object. The following example prints the length of the extent in each dimension of an

array_view object.

剩余1553页未读，继续阅读

tissar

粉丝: 51
资源: 1

Visual C++并行编程指南：AMP与C++AMP详解

Parallel Programming

Programming Visual C++

使用Microsoft Visual C ++进行并行编程（英文）

parallel programming in c with mpi and openmp solution manual

visual c++并行编程实战

parallel programming: concepts and practice pdf

如何使用Microsoft Visual C++ 6.0进行图像处理？

#pragma omp parallel for c++代码示例

in praise of programming massively parallel processors

pragma omp parallel for

parallel mode only supports posix system

programming massively parallel processors second edition

Error(s) in loading state_dict for DataParallel:

fortran openmp

use matlab to Plot the voltage gain of the RCL circuit when the capacitor and the inductor are in parallel in different frequency

Visual Studio运行OpenMP

parallel 和parallel for

verilog实现3输入多bit并转串

查询以下文献的GB/T 7713.1-2006的标准格式，包含期、卷和起止页码： MA Z, CHEN X, MA T, et al. Deep Deterministic Policy Gradient Based Resource Allocation in Internet of Vehicles[C].PAAP 2020: Parallel Architectures, Algorithms and Programming ,2020,pp. 295–306.

Parallel Build功能 如何开启

最新资源

Parallel Build功能如何开启