OpenACC 异步计算

▶ 按照书上的例子，使用 async 导语实现主机与设备端的异步计算

● 代码，非异步的代码只要将其中的 async 以及第 29 行删除即可

 #include <stdio.h>
 #include <stdlib.h>
 #include <openacc.h>

 #define N       10240000
 #define COUNT   200                         // 多算几次，增加耗时

 int main()
 {
     int *a = (int *)malloc(sizeof(int)*N);
     int *b = (int *)malloc(sizeof(int)*N);
     int *c = (int *)malloc(sizeof(int)*N);

 #pragma acc enter data create(a[0:N]) async // 在设备上赋值 a
     for (int i = ; i < COUNT; i++)
     {
 #pragma acc parallel loop async
         for (int j = ; j < N; j++)
             a[j] = (i + j) * ;
     }

     for (int i = ; i < COUNT; i++)         // 在主机上赋值 b
     {
         for (int j = ; j < N; j++)
             b[j] = (i + j) * ;
     }

 #pragma acc update host(a[0:N]) async       // 异步必须 update a，否则还没同步就参与 c 的运算
 #pragma acc wait                            // 非异步时去掉该行

     for (int i = ; i < N; i++)
         c[i] = a[i] + b[i];

 #pragma acc update device(a[0:N]) async     // 没啥用，增加耗时
 #pragma acc exit data delete(a[0:N])

     printf("\nc[1] = %d\n", c[]);
     free(a);
     free(b);
     free(c);
     //getchar();
     return ;
 }

● 输出结果（是否异步，差异仅在行号、耗时上）

//+-----------------------------------------------------------------------------非异步
D:\Code\OpenACC\OpenACCProject\OpenACCProject>pgcc main.c -acc -Minfo -o main_acc.exe
main:
     , Generating enter data create(a[:])
     , Accelerator kernel generated
         Generating Tesla code
         , #pragma acc loop gang, vector(128) /* blockIdx.x threadIdx.x */
     , Generating implicit copyout(a[:])
     , Generating update self(a[:])
     , Generating update device(a[:])
         Generating exit data delete(a[:])

D:\Code\OpenACC\OpenACCProject\OpenACCProject>main_acc.exe
launch CUDA kernel  file=D:\Code\OpenACC\OpenACCProject\OpenACCProject\main.c function=main
line= device= threadid= queue= num_gangs= num_workers= vector_length= grid= block=
launch CUDA kernel  file=D:\Code\OpenACC\OpenACCProject\OpenACCProject\main.c function=main
line= device= threadid= queue= num_gangs= num_workers= vector_length= grid= block=

... // 省略

launch CUDA kernel  file=D:\Code\OpenACC\OpenACCProject\OpenACCProject\main.c function=main
line= device= threadid= queue= num_gangs= num_workers= vector_length= grid= block=

c[] =
PGI: "acc_shutdown" not detected, performance results might be incomplete.
 Please add the call "acc_shutdown(acc_device_nvidia)" to the end of your application to ensure that the performance results are complete.

Accelerator Kernel Timing data
D:\Code\OpenACC\OpenACCProject\OpenACCProject\main.c
  main  NVIDIA  devicenum=
    time(us): ,
    : data region reached  time
    : compute region reached  times
        : kernel launched  times
            grid: []  block: []
            elapsed time(us): total=, max= min= avg=
    : data region reached  times
    : update directive reached  time
        : data copyout transfers:
             device time(us): total=, max=, min= avg=,
    : update directive reached  time
        : data copyin transfers:
             device time(us): total=, max=, min= avg=,
    : data region reached  time

//------------------------------------------------------------------------------有异步
D:\Code\OpenACC\OpenACCProject\OpenACCProject>pgcc main.c -acc -Minfo -o main_acc.exe
main:
     , Generating enter data create(a[:])
     , Accelerator kernel generated
         Generating Tesla code
         , #pragma acc loop gang, vector(128) /* blockIdx.x threadIdx.x */
     , Generating implicit copyout(a[:])
     , Generating update self(a[:])
     , Generating update device(a[:])
         Generating exit data delete(a[:])

D:\Code\OpenACC\OpenACCProject\OpenACCProject>main_acc.exe
launch CUDA kernel  file=D:\Code\OpenACC\OpenACCProject\OpenACCProject\main.c function=main
line= device= threadid= queue= num_gangs= num_workers= vector_length= grid= block=
launch CUDA kernel  file=D:\Code\OpenACC\OpenACCProject\OpenACCProject\main.c function=main
line= device= threadid= queue= num_gangs= num_workers= vector_length= grid= block=

... // 省略

launch CUDA kernel  file=D:\Code\OpenACC\OpenACCProject\OpenACCProject\main.c function=main
line= device= threadid= queue= num_gangs= num_workers= vector_length= grid= block=

c[] =
PGI: "acc_shutdown" not detected, performance results might be incomplete.
 Please add the call "acc_shutdown(acc_device_nvidia)" to the end of your application to ensure that the performance results are complete.

Accelerator Kernel Timing data
    Timing may be affected by asynchronous behavior
    set PGI_ACC_SYNCHRONOUS to  to disable async() clauses
D:\Code\OpenACC\OpenACCProject\OpenACCProject\main.c
  main  NVIDIA  devicenum=
    time(us): ,
    : data region reached  time
    : compute region reached  times
        : kernel launched  times
            grid: []  block: []
            elapsed time(us): total=, max= min= avg=
    : data region reached  times
    : update directive reached  time
        : data copyout transfers:
             device time(us): total=, max=, min= avg=,
    : update directive reached  time
        : data copyin transfers:
             device time(us): total=, max=, min= avg=,
    : data region reached  time

● Nvvp 的结果，我是真没看出来有较大的差别，可能例子举得不够好

● 在一个设备上同时使用两个命令队列

 #include <stdio.h>
 #include <stdlib.h>
 #include <openacc.h>

 #define N       10240000
 #define COUNT   200

 int main()
 {
     int *a = (int *)malloc(sizeof(int)*N);
     int *b = (int *)malloc(sizeof(int)*N);
     int *c = (int *)malloc(sizeof(int)*N);

 #pragma acc enter data create(a[0:N]) async(1)
     for (int i = ; i < COUNT; i++)
     {
 #pragma acc parallel loop async(1)
         for (int j = ; j < N; j++)
             a[j] = (i + j) * ;
     }

 #pragma acc enter data create(b[0:N]) async(2)
     for (int i = ; i < COUNT; i++)
     {
 #pragma acc parallel loop async(2)
         for (int j = ; j < N; j++)
             b[j] = (i + j) * ;
     }

 #pragma acc enter data create(c[0:N]) async(2)
 #pragma acc wait(1) async(2)

 #pragma acc parallel loop async(2)
     for (int i = ; i < N; i++)
         c[i] = a[i] + b[i];

 #pragma acc update host(c[0:N]) async(2)
 #pragma acc exit data delete(a[0:N], b[0:N], c[0:N]) 

     printf("\nc[1] = %d\n", c[]);
     free(a);
     free(b);
     free(c);
     //getchar();
     return ;
 }

● 输出结果

D:\Code\OpenACC\OpenACCProject\OpenACCProject>pgcc main.c -acc -Minfo -o main_acc.exe
main:
     , Generating enter data create(a[:])
     , Accelerator kernel generated
         Generating Tesla code
         , #pragma acc loop gang, vector(128) /* blockIdx.x threadIdx.x */
     , Generating implicit copyout(a[:])
     , Generating enter data create(b[:])
     , Accelerator kernel generated
         Generating Tesla code
         , #pragma acc loop gang, vector(128) /* blockIdx.x threadIdx.x */
     , Generating implicit copyout(b[:])
     , Generating enter data create(c[:])
     , Accelerator kernel generated
         Generating Tesla code
         , #pragma acc loop gang, vector(128) /* blockIdx.x threadIdx.x */
     , Generating implicit copyout(c[:])
         Generating implicit copyin(b[:],a[:])
     , Generating update self(c[:])
         Generating exit data delete(c[:],b[:],a[:])

D:\Code\OpenACC\OpenACCProject\OpenACCProject>main_acc.exe

c[] =
PGI: "acc_shutdown" not detected, performance results might be incomplete.
 Please add the call "acc_shutdown(acc_device_nvidia)" to the end of your application to ensure that the performance results are complete.

Accelerator Kernel Timing data
    Timing may be affected by asynchronous behavior
    set PGI_ACC_SYNCHRONOUS to  to disable async() clauses
D:\Code\OpenACC\OpenACCProject\OpenACCProject\main.c
  main  NVIDIA  devicenum=
    time(us): ,
    : data region reached  time
    : compute region reached  times
        : kernel launched  times
            grid: []  block: []
            elapsed time(us): total=, max= min= avg=
    : data region reached  times
    : data region reached  time
    : compute region reached  times
        : kernel launched  times
            grid: []  block: []
            elapsed time(us): total=, max= min= avg=
    : data region reached  times
    : data region reached  time
    : compute region reached  time
        : kernel launched  time
            grid: []  block: []
             device time(us): total= max= min= avg=
    : data region reached  times
    : update directive reached  time
        : data copyout transfers:
             device time(us): total=, max=, min= avg=,
    : data region reached  time

● Nvvp 中，可以看到两个命令队列交替执行

● 在 PGI 命令行中使用命令 pgaccelinfo 查看设备信息

D:\Code\OpenACC\OpenACCProject\OpenACCProject>pgaccelinfo

CUDA Driver Version:           

Device Number:
Device Name:                   GeForce GTX
Device Revision Number:        6.1
Global Memory Size:
Number of Multiprocessors:
Concurrent Copy and Execution: Yes
Total Constant Memory:
Total Shared Memory per Block:
Registers per Block:
Warp Size:
Maximum Threads per Block:
Maximum Block Dimensions:      , ,
Maximum Grid Dimensions:        x  x
Maximum Memory Pitch:          2147483647B
Texture Alignment:             512B
Clock Rate:                     MHz
Execution Timeout:             Yes
Integrated Device:             No
Can Map Host Memory:           Yes
Compute Mode:                  default
Concurrent Kernels:            Yes
ECC Enabled:                   No
Memory Clock Rate:              MHz
Memory Bus Width:               bits
L2 Cache Size:                  bytes
Max Threads Per SMP:
Async Engines:                         // 有两个异步引擎，支持两个命令队列并行
Unified Addressing:            Yes
Managed Memory:                Yes
Concurrent Managed Memory:     No
PGI Compiler Option:           -ta=tesla:cc60