NVIDIA HPC SDK

https://docs.nvidia.com/hpc-sdk/
Admin
NVIDIA HPC SDK is a comprehensive suite of compilers, libraries, and tools for developing...
Tokens:201,106
Snippets:2,613
Trust Score:10
Update:3 months ago
Show doc for...
Tokens:
Raw
### Makefile Configuration for IPA

Source: https://docs.nvidia.com/hpc-sdk/compilers/c%2B%2B-parallel-algorithms/index.html

Example Makefile setup to automate the build process with -Mipa.

```makefile
OPT=-Mipa=fast
a.out: file1.o file2.o file3.o
 nvc $(OPT) -o a.out file1.o file2.o file3.o
file1.o: file1.c
 nvc $(OPT) -c file1.c
file2.o: file2.c
 nvc $(OPT) -c file2.c
file3.o: file3.c
 nvc $(OPT) -c file3.c
```

--------------------------------

### Access OpenACC examples in Docker

Source: https://docs.nvidia.com/hpc-sdk/container-guide/index.html

Starts an interactive session in the devel container to access and build provided OpenACC samples.

```bash
$ sudo docker run --gpus all -it --rm nvcr.io/nvidia/nvhpc:26.5-devel-cuda_multi-ubuntu22.04
# cd /opt/nvidia/hpc_sdk/Linux_x86_64/26.5/examples/OpenACC/samples
# make all
```

--------------------------------

### Usage Examples for ANY Intrinsic

Source: https://docs.nvidia.com/hpc-sdk/compilers/cuda-fortran-prog-guide/index.html

Provides examples of using the ANY intrinsic with device or managed arrays.

```Fortran
IF (ANY(A .EQ. B)) PRINT *,"FAILED"
IF (ANY(ABS(A) .GT. X)) CALL REDO()
```

--------------------------------

### Compile Linear Algebra Example for CPU

Source: https://docs.nvidia.com/hpc-sdk/compilers/c%2B%2B-parallel-algorithms/index.html

Command to compile the linear algebra example for CPU execution using OpenBLAS.

```bash
nvc++ -std=c++17 -stdpar=multicore -o example example.cpp -lblas
```

--------------------------------

### Copy MPI Benchmarking Examples

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-user-guide/index.html

Command to copy the provided MPI example programs to a local directory.

```bash
% cp -r /opt/nvidia/hpc_sdk/Linux_x86_64/25.7/examples/MPI .
```

--------------------------------

### Usage Examples for ALL Intrinsic

Source: https://docs.nvidia.com/hpc-sdk/compilers/cuda-fortran-prog-guide/index.html

Provides examples of using the ALL intrinsic with device or managed arrays.

```Fortran
IF (ALL(A .EQ. B)) PRINT *,"PASSED"
IF (ALL(ABS(A - B) .GT. X)) CALL REDO()
```

--------------------------------

### Build application with IPA

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-user-guide/index.html

Example commands for building applications with Interprocedural Analysis enabled.

```bash
$ nvc -Mipa=fast -o app1 main1.c sub.c
```

```bash
$ nvc -Mipa=fast -o app2 main2.c sub.c
```

--------------------------------

### Configure network installation host

Source: https://docs.nvidia.com/hpc-sdk/hpc-sdk-install-guide/index.html

Run this command on each system in a network installation to create the necessary local configuration files.

```bash
/opt/nvidia/hpc_sdk/$NVARCH/26.5/compilers/bin/add_network_host
```

--------------------------------

### Compile Linear Algebra Example for GPU

Source: https://docs.nvidia.com/hpc-sdk/compilers/c%2B%2B-parallel-algorithms/index.html

Command to compile the linear algebra example for GPU execution using cuBLAS.

```bash
nvc++ -std=c++17 -stdpar=gpu -cudalib=cublas -o example example.cpp
```

--------------------------------

### PCAST runtime API example

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-user-guide/index.html

Full example demonstrating the use of pcast_compare within a loop.

```c
#include <stdlib.h>
#include <openacc.h>

int main() {
 int size = 1000;
 int i, t;
 float *a1;
 float *a2;

 a1 = (float*)malloc(sizeof(float)*size);
 a2 = (float*)malloc(sizeof(float)*size);

 for (i = 0; i < size; i++) {
 a1[i] = 1.0f;
 a2[i] = 2.0f;
 }

 for (t = 0; t < 5; t++) {
 for(i = 0; i < size; i++) {
 a2[i] += a1[i];
 }
 pcast_compare(a2, "float", size, "a2", "example.c", "main", 23);
 }
 return 0;
}
```

--------------------------------

### Implement Compare Directive in C Example

Source: https://docs.nvidia.com/hpc-sdk/compilers/c%2B%2B-parallel-algorithms/index.html

The same logic as the runtime API example, but using the more concise directive syntax.

```C
#include <stdlib.h>
#include <openacc.h>

int main() {
    int size = 1000;
    int i, t;
    float *a1;
    float *a2;

    a1 = (float*)malloc(sizeof(float)*size);
    a2 = (float*)malloc(sizeof(float)*size);

    for (i = 0; i < size; i++) {
      a1[i] = 1.0f;
      a2[i] = 2.0f;
    }

    for (t = 0; t < 5; t++) {
    for(i = 0; i < size; i++) {
      a2[i] += a1[i];
    }
    #pragma nvidia compare(a2[0:size])
    }
    return 0;
}
```

--------------------------------

### Fortran INCLUDE statement examples

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-ref-guide/index.html

Examples of absolute, relative, and local path usage in Fortran INCLUDE statements.

```fortran
INCLUDE '/bob/include/file1' (absolute path name)
INCLUDE '../../file1' (relative path name)
```

```fortran
INCLUDE 'file1'
```

--------------------------------

### Linear Algebra Example Output

Source: https://docs.nvidia.com/hpc-sdk/compilers/c%2B%2B-parallel-algorithms/index.html

Expected output when running the linear algebra example.

```text
y[0] = 2.500000
y[1] = 252.500000
y[2] = 502.500000
y[3] = 752.500000
```

--------------------------------

### PCAST directive example

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-user-guide/index.html

Example using the #pragma nvidia compare directive instead of the runtime API.

```c
#include <stdlib.h>
#include <openacc.h>

int main() {
 int size = 1000;
 int i, t;
 float *a1;
 float *a2;

 a1 = (float*)malloc(sizeof(float)*size);
 a2 = (float*)malloc(sizeof(float)*size);

 for (i = 0; i < size; i++) {
 a1[i] = 1.0f;
 a2[i] = 2.0f;
 }

 for (t = 0; t < 5; t++) {
 for(i = 0; i < size; i++) {
 a2[i] += a1[i];
 }
 #pragma nvidia compare(a2[0:size])
 }
 return 0;
}
```

--------------------------------

### Compile Linear Algebra Example

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-user-guide/index.html

Compilation commands for GPU and CPU execution targets.

```bash
nvc++ -std=c++17 -stdpar=gpu -cudalib=cublas -o example example.cpp
```

```bash
nvc++ -std=c++17 -stdpar=multicore -o example example.cpp -lblas
```

--------------------------------

### Compilation and execution commands

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-user-guide/index.html

Commands to compile the example and run it with PCAST environment variables.

```bash
$ nvc -fast -o a.out example.c
```

```bash
$ PCAST_COMPARE=summary,rel=1 ./out.o
datafile pcast_compare.dat created with 5 blocks, 5000 elements, 20000 bytes
```

```bash
$ PCAST_COMPARE=summary,rel=1 ./out.o
datafile pcast_compare.dat compared with 5 blocks, 5000 elements, 20000 bytes
no errors found
 relative tolerance = 0.100000, rel=1
```

--------------------------------

### CUFFT Module Usage

Source: https://docs.nvidia.com/hpc-sdk/compilers/cuda-fortran-prog-guide/index.html

Demonstrates the inclusion of the cufft module and a 2D FFT execution example.

```Fortran
use cufft
```

```Fortran
program cufft2dTest
  use cufft
  integer, parameter :: n=450
  complex :: a(n,n),b(n,n)
  complex, device :: a_d(n,n), b_d(n,n)
  integer :: plan, ierr
  real, dimension(3) :: res, exp

  a  = 1; a_d  = a

  ierr = cufftPlan2D(plan,n,n,CUFFT_C2C)
  ierr = ierr + cufftExecC2C(plan,a_d,b_d,CUFFT_FORWARD)
  ierr = ierr + cufftExecC2C(plan,b_d,b_d,CUFFT_INVERSE)

  b = b_d
  res(1) = maxval(abs(a-b/(n*n)))
  print *,'Max error C2C: ', res(1)
```

--------------------------------

### Inefficient Dockerfile Layering Example

Source: https://docs.nvidia.com/hpc-sdk/container-guide/index.html

This example demonstrates how multiple RUN instructions can lead to bloated image sizes due to file-level deduplication, where temporary files remain in the image history.

```dockerfile
RUN mkdir /source
RUN cd /source && git clone https://github.com/UoB-HPC/CloverLeaf-OpenACC.git
RUN cd /source/CloverLeaf-OpenACC && make COMPILER=PGI FLAGS_PGI="-Mpreprocess -fast -acc -Minfo=acc -gpu=ccall -tp=px"
RUN mkdir -p /opt/CloverLeaf-OpenACC
RUN install -m 755 -d /opt/CloverLeaf-OpenACC/bin
RUN install -m 755 clover_leaf /opt/CloverLeaf-OpenACC/bin/clover_leaf
RUN install -m 755 -d /opt/CloverLeaf-OpenACC/InputDecks
RUN install -m 644 InputDecks/* /opt/CloverLeaf-OpenACC/InputDecks
RUN rm -rf /source/CloverLeaf-OpenACC
```

--------------------------------

### Fortran Data Synchronization Example

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-user-guide/index.html

Example showing how Unified Memory Mode can change the outcome of data synchronization compared to Separate Memory Mode.

```fortran
b(:) = ...
c = 0

!$acc kernels copyin(b) copyout(a)
!$acc loop
do i = 1, N
 b(i) = b(i) * i
end do
!$acc loop
do i = 1, N
 a(i) = b(i) + i
end do
!$acc end kernels

do i = 1, N
 c = c + a(i) + b(i)
end do
```

--------------------------------

### IPA-Optimized Object Files

Source: https://docs.nvidia.com/hpc-sdk/compilers/c%2B%2B-parallel-algorithms/index.html

Example of the object files generated by the IPA linker.

```text
main2_ipa4_app2.oo sub_ipa4_app2.oo
```

--------------------------------

### Generate make dependencies to stdout

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-ref-guide/index.html

Example of generating make dependencies and printing them to standard output.

```bash
$ nvc++ -M myprog.cc
```

--------------------------------

### Generate make dependencies to a file

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-ref-guide/index.html

Example of generating make dependencies and saving them to a file.

```bash
$ nvc++ -MD myprog.cc
```

--------------------------------

### Metadirective Device Matching

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-user-guide/index.html

Examples showing how the compiler matches device architectures for target constructs.

```C
#pragma omp target map(to:v1,v2) map(from:v3)
#pragma omp metadirective \
when( device={arch("nvptx")} : teams distribute parallel for) \
default( parallel for)
 for (int i = 0; i < N; i++) {
 v3[i] = v1[i] * v2[i];
 }
```

```C
#pragma omp target teams distribute map(to:v1,v2) map(from:v3)
for (...)
{
#pragma omp metadirective \
when( device={arch("nvptx")} : parallel for) \
default( simd )
 for (int i = 0; i < N; i++) {
 v3[i] = v1[i] * v2[i];
 }
}
```

--------------------------------

### Use UNPACK Function

Source: https://docs.nvidia.com/hpc-sdk/compilers/cuda-fortran-prog-guide/index.html

Examples showing UNPACK usage with and without the optional field argument.

```fortran
C = UNPACK(D, ABS(A - B) .GT. x)
C = UNPACK(D, MASK=(ABS(A - B) .GT. x), FIELD=y)
```

--------------------------------

### Build and run the step1 tutorial

Source: https://docs.nvidia.com/hpc-sdk/compilers/openacc-mpi-tutorial/index.html

Commands to compile and execute the tutorial code using the provided Makefile.

```bash
cd step1
make build
make run
make verify
```

--------------------------------

### Build and Run Step 4 Example

Source: https://docs.nvidia.com/hpc-sdk/compilers/openacc-mpi-tutorial/index.html

Commands to compile, execute, and verify the optimized step 4 code.

```bash
cd step4
make build
make run
make verify
```

--------------------------------

### OpenACC Compilation Error

Source: https://docs.nvidia.com/hpc-sdk/compilers/c%2B%2B-parallel-algorithms/index.html

Example of a compilation and execution failure due to a mismatch between the generated PTX and the installed CUDA driver.

```bash
$ nvc -acc -gpu=cc70 app.c
$ ./a.out
Accelerator Fatal Error: This file was compiled: -acc=gpu -gpu=cc70
Rebuild this file with -gpu=cc80 to use NVIDIA Tesla GPU 0
NVIDIA CUDA PTX JIT Compiler was unable to compile device code.
This file was compiled with NVIDIA CUDA Toolkit 12.9, the current CUDA Driver is 12.1.
Rebuild the application with the NVHPC_CUDA_HOME environment variable set to the matching CUDA Tookit.
Please consult the NVIDIA HPC Compilers User's Guide for details.
File: /tmp/app.c
Function: main:5
Line: 5
```

--------------------------------

### Link with Custom Library Directory

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-ref-guide/index.html

Example of specifying a library directory for the linker to use during compilation.

```bash
$ nvfortran -L/lib myprog.f
```

--------------------------------

### Build a Program with IPA in Multiple Steps

Source: https://docs.nvidia.com/hpc-sdk/compilers/c%2B%2B-parallel-algorithms/index.html

Demonstrates compiling individual source files with -Mipa and linking them into an executable.

```bash
$ nvc -Mipa=fast -c file1.c
$ nvc -Mipa=fast -c file2.c
$ nvc -Mipa=fast -c file3.c
$ nvc -Mipa=fast -o a.out file1.o file2.o file3.o
```

--------------------------------

### Get device symbol address with cudaGetSymbolAddress

Source: https://docs.nvidia.com/hpc-sdk/compilers/cuda-fortran-prog-guide/index.html

Returns the address of a device symbol. Includes an example of initializing a global device array from a kernel.

```fortran
integer function cudaGetSymbolAddress(devptr, symbol)
    type(C_DEVPTR) :: devptr
    type(c_ptr) :: symbol
```

```fortran
type(c_ptr) :: csvx
type(c_devptr) :: cdvx
real, allocatable, device :: vx(:)
csvx = 'vx'
Istat = cudaGetSymbolAddress(cdvx, csvx)
Call c_f_pointer(cdvx, vx, 100)
Vx = 0.0
```

--------------------------------

### Build and Run Commands

Source: https://docs.nvidia.com/hpc-sdk/compilers/openacc-mpi-tutorial/index.html

Standard commands to compile, execute, and verify the step2 tutorial project.

```bash
cd step2
make build
make run
make verify
```

--------------------------------

### Build and Run Step 5 Project

Source: https://docs.nvidia.com/hpc-sdk/compilers/openacc-mpi-tutorial/index.html

Commands to navigate to the project directory, compile the code, execute it, and verify the results.

```bash
cd step5
make build
make run
make verify
```

--------------------------------

### mdspan Example Output

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-user-guide/index.html

Expected console output after executing the compiled mdspan example.

```text
m(0, 0) == 0
m(0, 1) == 5
m(0, 2) == 1
m(1, 0) == 3
m(1, 1) == 8
m(1, 2) == 4
m(2, 0) == 2
m(2, 1) == 7
m(2, 2) == 6
```

--------------------------------

### Build and Run Step 3

Source: https://docs.nvidia.com/hpc-sdk/compilers/openacc-mpi-tutorial/index.html

Commands to compile, execute, and verify the optimized code.

```bash
cd step3
make build
make run
make verify
```

--------------------------------

### Manual build steps with IPA

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-user-guide/index.html

Demonstrates the underlying steps performed by the compiler driver when using -Mipa, including assembly generation and linking.

```bash
$ nvc -Mipa=fast -S -o file1.s file1.c
$ as -o file1.o file1.s
$ nvc -Mipa=fast -S -o file2.s file2.c
$ as -o file2.o file2.s
$ nvc -Mipa=fast -S -o file3.s file3.c
$ as -o file3.o file3.s
$ nvc -Mipa=fast -o a.out file1.o file2.o file3.o
```

--------------------------------

### Compiling mdspan example with NVC++

Source: https://docs.nvidia.com/hpc-sdk/compilers/c%2B%2B-parallel-algorithms/index.html

Command to compile the mdspan example using the -stdpar flag.

```bash
nvc++ -stdpar -std=c++17 -o example example.cpp
```

--------------------------------

### Building a Program with IPA via Command Line

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-user-guide/index.html

Use the -Mipa switch to compile source files individually and link them into an executable.

```bash
$ nvc -Mipa=fast -c file1.c
$ nvc -Mipa=fast -c file2.c
$ nvc -Mipa=fast -c file3.c
$ nvc -Mipa=fast -o a.out file1.o file2.o file3.o
```

```bash
$ nvc -Mipa=fast -c file1.c
$ nvc -Mipa=fast -o a.out file1.o file2.o file3.o
```

--------------------------------

### Build Multiple Applications with IPA

Source: https://docs.nvidia.com/hpc-sdk/compilers/c%2B%2B-parallel-algorithms/index.html

Example command for building an application with shared source files using -Mipa.

```bash
$ nvc -Mipa=fast -o app1 main1.c sub.c
```

--------------------------------

### Warp Reduction Example

Source: https://docs.nvidia.com/hpc-sdk/compilers/cuda-fortran-prog-guide/index.html

Example of using __shfl_xor to perform a sum reduction across a warp.

```Fortran
j = . . .
k = __shfl_xor(j,1);  j = j + k
k = __shfl_xor(j,2);  j = j + k
k = __shfl_xor(j,4);  j = j + k
k = __shfl_xor(j,8);  j = j + k
k = __shfl_xor(j,16); j = j + k
```

--------------------------------

### Querying Compiler Help

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-user-guide/index.html

Examples of using the -help flag to inspect specific compiler options or help categories.

```bash
$ nvfortran -help -fast
```

```bash
$ nvfortran -help -help
        -help[=groups|asm|debug|language|linker|opt|other|overall|phase|prepro|
         suffix|switch|target|variable]
```

--------------------------------

### acc compare Directive Usage Examples

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-user-guide/index.html

Examples of applying the acc compare directive to variables and arrays.

```c
#pragma acc compare(a[0:N])
#pragma acc compare all
```

```fortran
!$acc compare(a, b)
!$acc compare(a(1:N))
!$acc compare all
```

--------------------------------

### Initialize and Add SSE Variables

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-ref-guide/index.html

Example demonstrating the use of _mm_set_ps to initialize __m128 variables and _mm_add_ps to perform addition.

```c
#include<xmmintrin.h>
 int main(){
 __m128 A, B, result;
 A = _mm_set_ps(23.3, 43.7, 234.234, 98.746); /* initialize A */
 B = _mm_set_ps(15.4, 34.3, 4.1, 8.6); /* initialize B */
 result = _mm_add_ps(A, B);
 return 0;
 }
```

--------------------------------

### Unpack the HPC SDK tarball

Source: https://docs.nvidia.com/hpc-sdk/hpc-sdk-install-guide/index.html

Extract the installation files from the downloaded tar archive before running the installer.

```bash
% tar xpfz <tarfile>.tar.gz
```

--------------------------------

### Build and Run an Open MPI Program

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-user-guide/index.html

Commands to copy, compile, and execute an MPI example program using Open MPI wrappers.

```bash
$ cd my_example_dir
$ cp -r /opt/nvidia/hpc_sdk/Linux_x86_64/25.7/examples/MPI/samples/mpihello .
$ cd mpihello
$ export PATH=/opt/nvidia/hpc_sdk/Linux_x86_64/25.7/mpi/openmpi/bin:$PATH
$ mpifort mpihello.f -o mpihello

$ mpiexec mpihello
Hello world! I'm node 0

$ mpiexec -np 4 mpihello
Hello world! I'm node 0
Hello world! I'm node 2
Hello world! I'm node 1
Hello world! I'm node 3
```

--------------------------------

### Create a C hello world program

Source: https://docs.nvidia.com/hpc-sdk/hpc-sdk-install-guide/index.html

Use this C source file to verify that a GNU C compiler is installed and functional.

```c
#include <stdio.h>
int main() {
  printf("hello, world!\n");
  return 0;
}
```

--------------------------------

### Compiling mdspan Example

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-user-guide/index.html

Command to compile the mdspan example using the nvc++ compiler with C++17 standard support.

```bash
nvc++ -std=c++17 -o example example.cpp
```

--------------------------------

### Query compiler help information

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-user-guide/index.html

Use the -help flag to retrieve documentation for specific compiler options or to list available help groups.

```bash
$ nvfortran -help -O
```

```bash
$ nvfortran -help -help
```

--------------------------------

### Example Help Output

Source: https://docs.nvidia.com/hpc-sdk/compilers/c%2B%2B-parallel-algorithms/index.html

Sample output returned by the compiler when querying help for specific flags or the help system itself.

```text
-O Set opt level. All -O1 optimizations plus traditional scheduling and
  global scalar optimizations performed
```

```text
-help[=groups|asm|debug|language|linker|opt|other|overall|
phase|prepro|suffix|switch|target|variable]
Show compiler switches
```

--------------------------------

### Manual compilation and assembly steps

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-user-guide/index.html

Demonstrates the individual steps the compiler driver performs to generate assembly, object files, and the final executable.

```bash
$ nvc -S -o file1.s file1.c
$ as -o file1.o file1.s
$ nvc -S -o file2.s file2.c
$ as -o file2.o file2.s
$ nvc -S -o file3.s file3.c
$ as -o file3.o file3.s
$ nvc -o a.out file1.o file2.o file3.o
```

--------------------------------

### Specify driver configuration file with -rc

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-ref-guide/index.html

Sets the driver startup configuration file. The syntax requires a path and filename.

```bash
-rc [path] filename
```

```bash
$ nvfortran -rc .nvfortranrctest myprog.f
```

--------------------------------

### Extended Inline Assembly Example

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-user-guide/index.html

An example of extended assembly showing the use of output operands, input operands, and a clobber list.

```c
asm( "movl %1, %%eax\n" "movl %%eax, %0":"=r" (x) : "r" (y) : "%eax" );
```

--------------------------------

### OpenACC Parallel Loop with Trip Count Example

Source: https://docs.nvidia.com/hpc-sdk/compilers/c%2B%2B-parallel-algorithms/index.html

Example demonstrating an OpenACC parallel loop construct with data creation and kernel initialization.

```fortran
real :: array(1000, 10)
integer :: i, j, n, m

!$acc data create(n, m) copy(array)

!$acc kernels
n = 1000
m = 10
!$acc end kernels

!$acc parallel loop defualt(none) collapse(2)
do j=1,m
  do i=1,n
    array(i, j) = i+j
  end do
end do
```

--------------------------------

### OpenACC C Program Example

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-user-guide/index.html

An example of an OpenACC program demonstrating how data directives behave differently when compiled with Unified Memory Mode.

```c
int x[N];
void foo() {
 #pragma acc enter data create(x[0:N])
 #pragma acc parallel loop
 for (int i = 0; i < N; i++) {
 x[i] = i;
 }
}
```

--------------------------------

### Define x86-64 function parameter passing example

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-ref-guide/index.html

Example demonstrating a function declaration and call used to illustrate register allocation and stack frame offsets.

```c
typedef struct {
    int a, b;
    double d;
    }
    structparam;
    structparam s;
    int e, f, g, h, i, j, k;
    float flt;
    double m, n;
    extern void func(int e, int f, structparam s, int g, int h,
    float flt, double m, double n, int i, int j, int k);
    void func2()
    {
    func(e, f, s, g, h, flt, m, n, i, j, k);
    }
```

--------------------------------

### OpenACC Trip Count Example

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-user-guide/index.html

Example demonstrating a scenario where trip count variables are initialized on the device, requiring specific compiler flags for correct loop execution.

```Fortran
real :: array(1000, 10)
integer :: i, j, n, m

!$acc data create(n, m) copy(array)

!$acc kernels
n = 1000
m = 10
!$acc end kernels

!$acc parallel loop defualt(none) collapse(2)
do j=1,m
 do i=1,n
 array(i, j) = i+j
 end do
end do
```

--------------------------------

### Build a program with IPA in a single step

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-user-guide/index.html

Use the -Mipa flag to compile and link multiple source files with interprocedural optimizations in one command.

```bash
$ nvc -Mipa=fast -o a.out file1.c file2.c file3.c
```

--------------------------------

### cudaDriverGetVersion

Source: https://docs.nvidia.com/hpc-sdk/compilers/cuda-fortran-prog-guide/index.html

Retrieves the installed CUDA driver version.

```APIDOC
## integer function cudaDriverGetVersion(iversion)

### Description
Returns the version number of the installed CUDA driver as iversion. Returns 0 if no driver is installed.

### Parameters
- **iversion** (integer) - Required - Output variable for the version number.
```

--------------------------------

### Use Builtin Math Functions in C

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-user-guide/index.html

Example demonstrating the inclusion of math.h to enable efficient builtin math function calls.

```c
#include <math.h>
#include <stdio.h>
#define PI 3.1415926535
void main()
{
  double x, y;
  x = PI/3.0;
  y = acos(0.5);
  printf('%f %f\n',x,y);
}
```

--------------------------------

### cudaFuncGetAttributes

Source: https://docs.nvidia.com/hpc-sdk/compilers/cuda-fortran-prog-guide/index.html

Gets the attributes for a specified global function.

```APIDOC
## integer function cudaFuncGetAttributes( attr, func )

### Description
Gets the attributes for the function named by the func argument, which must be a global function. Available in device code starting in CUDA 5.0.

### Parameters
- **attr** (type(cudaFuncAttributes)) - Required - Output structure for function attributes.
- **func** (external) - Required - The global function to query.
```

--------------------------------

### Link with Multiple Library Directories

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-ref-guide/index.html

Example of specifying multiple library directories and linking specific libraries from them.

```bash
$ nvfortran -L/lib -lx -L/libz -ly myprog.f
```

--------------------------------

### Standard sorting example

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-user-guide/index.html

A standard sequential sort operation.

```cpp
std::sort(employees.begin(), employees.end(),
 CompareByLastName());
```

--------------------------------

### Get Stream Priority

Source: https://docs.nvidia.com/hpc-sdk/compilers/cuda-fortran-prog-guide/index.html

Queries the priority of a given stream.

```fortran
integer function cudaStreamGetPriority( stream, priority )
    integer(kind=cuda_stream_kind), intent(in) :: stream
    integer, intent(out) :: priority
```

--------------------------------

### Use COUNT_PREFIX Function

Source: https://docs.nvidia.com/hpc-sdk/compilers/cuda-fortran-prog-guide/index.html

Examples demonstrating various configurations of the COUNT_PREFIX function including dimension and exclusivity options.

```fortran
C = COUNT_PREFIX(A .GT. 0)
C = COUNT_PREFIX(A .EQ. B, DIM=1)
C = COUNT_PREFIX(MASK=ABS(A - B) .LE. x, DIM=2, EXCLUSIVE=.true.)
```

--------------------------------

### Examples of FORT_CONVERT_UNIT usage

Source: https://docs.nvidia.com/hpc-sdk/compilers/c%2B%2B-parallel-algorithms/index.html

Various configurations for global and unit-specific endianness.

```text
FORT_CONVERT_UNIT=big_endian
```

```text
FORT_CONVERT_UNIT=big_endian:10,20-30
```

```text
FORT_CONVERT_UNIT=10,20-30
```

```text
FORT_CONVERT_UNIT=big_endian:10,20-30
```

```text
FORT_CONVERT_UNIT=big_endian;little_endian:11,12,13;swap:14,15,16:native:17,20-22
```

--------------------------------

### Building a Program with IPA Using Make

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-user-guide/index.html

Integrate IPA into a Makefile by defining the compiler options and using the make utility.

```makefile
OPT=-Mipa=fast
a.out: file1.o file2.o file3.o
 nvc $(OPT) -o a.out file1.o file2.o file3.o
file1.o: file1.c
 nvc $(OPT) -c file1.c
file2.o: file2.c
 nvc $(OPT) -c file2.c
file3.o: file3.c
 nvc $(OPT) -c file3.c
```

```bash
$ make
```

--------------------------------

### Expected program output

Source: https://docs.nvidia.com/hpc-sdk/compilers/c%2B%2B-parallel-algorithms/index.html

The standard output produced by the example program.

```text
hello
```

--------------------------------

### Build a program in a single step

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-user-guide/index.html

Compiles and links multiple source files into one executable using the nvc driver.

```bash
$ nvc -o a.out file1.c file2.c file3.c
```

--------------------------------

### Parallel sorting example

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-user-guide/index.html

Parallelized sort using the execution policy.

```cpp
std:sort(std::execution::par,
 employees.begin(), employees.end(),
 CompareByLastName());
```

--------------------------------

### Metadirective with GPU and Host Fallback

Source: https://docs.nvidia.com/hpc-sdk/compilers/c%2B%2B-parallel-algorithms/index.html

Example showing how to match device architecture for GPU code while providing a default fallback for the host.

```cpp
#pragma omp target teams distribute map(to:v1,v2) map(from:v3)
for (...) 
{
#pragma omp metadirective \
when( device={arch("nvptx")} : parallel for) \
default( simd )
  for (int i = 0; i < N; i++) {
    v3[i] = v1[i] * v2[i];
  }
}
```

--------------------------------

### Execute non-vectorized program

Source: https://docs.nvidia.com/hpc-sdk/compilers/c%2B%2B-parallel-algorithms/index.html

Example output of a standard execution of the vadd program.

```bash
$ /bin/time vadd
   -1.000000       -771.0000       -3618.000       -6498.000
   -9999.000
2.31user 0.00system 0:02.57elapsed 89%CPU (0avgtext+0avgdata 6976maxresident)k
8192inputs+0outputs (0major+149minor)pagefaults 0swaps
```

--------------------------------

### Parallel transform_reduce example

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-user-guide/index.html

Parallelized average age calculation using transform_reduce.

```cpp
int ave_age =
 std::transform_reduce(std::execution::par_unseq,
 employees.begin(), employees.end(),
 0, std::plus<int>(),
 [](const Employee& emp){
 return emp.age();
 })
 / employees.size();
```

--------------------------------

### Sequential accumulation example

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-user-guide/index.html

Calculating average age using standard accumulate.

```cpp
int ave_age =
 std::accumulate(employees.begin(), employees.end(), 0,
 [](int sum, const Employee& emp){
 return sum + emp.age();
 })
 / employees.size();
```

--------------------------------

### Display driver configuration with -show

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-ref-guide/index.html

Outputs driver configuration information to standard output.

```bash
$ nvfortran -show myprog.f
```

--------------------------------

### Get CUDA function attributes

Source: https://docs.nvidia.com/hpc-sdk/compilers/cuda-fortran-prog-guide/index.html

Retrieves attributes for a global kernel function.

```fortran
integer function cudaFuncGetAttributes( attr, func )
    type(cudaFuncAttributes), intent(out) :: attr
    external :: func
```

--------------------------------

### Begin CUDA Stream Capture

Source: https://docs.nvidia.com/hpc-sdk/compilers/cuda-fortran-prog-guide/index.html

Starts graph capture on the specified stream.

```fortran
integer function cudaStreamBeginCapture( stream, mode )
    integer(kind=cuda_stream_kind), intent(in) :: stream
    integer, intent(in) :: mode
```

--------------------------------

### Display help for a specific compiler option

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-ref-guide/index.html

Prints usage information for the -Minline option to standard output.

```bash
$ nvc -help -Minline
-Minline[=lib:<inlib>|<maxsize>|<func>|except:<func>|name:<func>|maxsize:<n>|
totalsize:<n>|smallsize:<n>|reshape]
                    Enable function inlining
    lib:<inlib>     Use extracted functions from inlib
    <maxsize>       Set maximum function size to inline
    <func>          Inline function func
    except:<func>   Do not inline function func
    name:<func>     Inline function func
    maxsize:<n>     Inline only functions smaller than n
    totalsize:<n>   Limit inlining to total size of n
    smallsize:<n>   Always inline functions smaller than n
    reshape         Allow inlining in Fortran even when array shapes do not
                    match
    pragma          Fortran Only: Inline only those procedures that have the
                    ``!NVF$ INLINE`` pragma on the source line
                    immediately before the procedure's SUBROUTINE or
                    FUNCTION statement.
    -Minline        Inline all functions that were extracted
```

--------------------------------

### Define Debugger Command

Source: https://docs.nvidia.com/hpc-sdk/compilers/hpc-compilers-user-guide/index.html

Example format for setting the NVCOMPILER_TERM_DEBUG variable to invoke a debugger.

```text
> gdb –quiet –pid %d
```

--------------------------------

### Create and compile C++ hello world program

Source: https://docs.nvidia.com/hpc-sdk/hpc-sdk-install-guide/index.html

Verify C++ compiler support by creating and compiling a simple C++ source file.

```cpp
#include <iostream>
int main() {
  std::cout << "hello, world!\n";
  return 0;
}
```

```bash
$ g++ -o hello_cpp hello.cpp
```
Tokens:
Raw