DOCUMENTATION

Le Nvidia HPC SDK est une suite de compilateurs, de bibliothèques et d'outils pour le HPC. PLus d'information sont disponibles ici.

Ce module donne notamment accès à Cuda et à des compilateurs compatibles avec l'API OpenACC. Pour l'utiliser, vous devez charger le module correspondant à la version désirée :

module load nvidia_hpc_sdk/21.2

CUDA

Cuda est une extension du langage C++ permettant d’accéder aux GPUs Nvidia du mésocentre.

Vous pouvez compiler vos propres codes avec le compilateur nvcc.

Exemple addition

Voici un simple code Cuda qui additionne 2 tableaux entre eux, ainsi que la marche à suivre pour le lancer sur les machines dédiées du mésocentre :

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#define N 1024
#define THREADS_PER_BLOCK 256

__global__ void add(int *d_a, int *d_b, int *d_c)
{
    int ind = threadIdx.x + blockIdx.x *blockDim.x;

    if (ind<N) d_c[ind] = d_a[ind] + d_b[ind];
}

int main(int argc,char *argv[])
{
    int *a,*b,*c;
    int size = N*sizeof(int);

    cudaMallocManaged(&a,size);
    cudaMallocManaged(&b,size);
    cudaMallocManaged(&c,size);

    srand(time(NULL));

    for (int ii=0; ii<N; ii++){
        a[ii] = 1+rand()%1000;
        b[ii] = 1+rand()%1000;
    }

    add<<<N/THREADS_PER_BLOCK,THREADS_PER_BLOCK>>>(a,b,c);
    cudaDeviceSynchronize();

    for (int ii=0; ii<N; ii++) printf("%d + %d = %d\n",a[ii],b[ii],c[ii]);

    cudaFree(a);
    cudaFree(b);
    cudaFree(c);

    return 0;
}

Compilation

nvcc add.cu -o add

Script de soumission

#! /bin/bash
#SBATCH -p publicgpu       # File d'attente GPU
#SBATCH -n 1
#SBATCH --gres=gpu:1       # Pour réserver une machine avec 1 GPU libre

module load nvidia_hpc_sdk/21.2

./add

Compilateurs C, C++ et Fortran

Des compilateurs sont également disponibles via les modules nvidia_hpc_sdk. Il s'agit des anciens compilateurs PGI du groupe Portland.

Les commandes pour ces compilateurs sont les suivantes :

Ces compilateurs peuvent être utilisé pour compiler des codes en multithreading, avec OpenMP par exemple. Pour cela, il faut ajouter l'option -mp en argument.

Voici un exemple de code C/OpenMP, ainsi que la façon de le compiler et de l'exécuter sur les machines du méso-centre.

hello.c

#include <stdio.h>
#include <omp.h>
#include <unistd.h>

int main (int argc, char *argv[])
{
  int nb_procs;   //Nombre de processus
  int rang;       //Rang du processus

  nb_procs = omp_get_max_threads();

#pragma omp parallel private(rang)
{
  rang = omp_get_thread_num();
  printf("Hello World de la part du thread %d/%d\n",rang,nb_procs);
}

return 0;
}

Compilation

nvc hello.c -o hello -mp -tp=sandybridge

N.B. : L'option -tp=sandybridge assure une compatibilité avec l'ensemble des nœuds du mésocentre. Si vous visez une architecture plus récente, vous pouvez enlever cette option, ou la remplacer avec avec l'architecture du processeur de la machine visée.

Script de soumission

#! /bin/bash

#SBATCH -N 1

module load nvidia_hpc_sdk/21.2

export OMP_NUM_THREADS=$SLURM_CPUS_ON_NODE  # Autant de threads OpenMP que de cœurs disponibles sur le nœud

./hello

Utilisation de GPU avec OpenACC

Les compilateurs Nvidia permettent d'utiliser l'API OpenACC afin de faire tourner les codes sur GPU.

Exemple de code OpenACC

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

void saxpy_acc(int N, float a, float *x, float *restrict y_acc)
{
    int i;
#pragma acc parallel loop
    for (i=0; i<N;i++)
        y_acc[i] += a * x[i];
}

void saxpy(int n, float a, float *x, float *y)
{
        int i;

        for (i=0; i<n;i++)
            y[i] += a * x[i];
}

int main (int argc, char **argv)
{
    int i, error;
    float *x,*y,*y_acc,a;
    int N = 1000000;
    size_t memsize;

    a=4.0;

    if (argc > 1 )
        N= atoi(argv[1]);

    memsize = N * sizeof(float);

    x     = (float*)malloc(memsize);
    y     = (float*)malloc(memsize);
    y_acc = (float*)malloc(memsize);

    for (i=0; i<N; i++){
        x[i]     = 1.0f;
        y[i]     = 2.0f;
            y_acc[i] = y[i];
    }

    saxpy(N, a, x, y);

    saxpy_acc(N, a, x, y_acc);

    error=0;

    for(i=0; i < N; i++)
        if(y_acc[i]!=y[i])
            error++;

    printf("test comparison shows %d errors\n",error);

    return 0;
}

Compilation

nvc -acc -ta=nvidia -tp=sandybridge saxpy.c -o saxpy

Script de soumission

#! /bin/bash

#SBATCH -N 1
#SBATCH -p publicgpu # Partition public avec des nœuds GPU
#SBATCH --gres=gpu:1 # Nombre de GPU par nœud

module load nvidia_hpc_sdk/21.2

./saxpy

VERSIONS ET SCRIPTS D'INSTALLATION

TAGS