DOCUMENTATION

/!\PGI est maintenant distribué par Nvidia. Ces compilateurs sont accessibles via les module nvidia_hpc_sdk/!\

Les compilateurs Portland sont disponibles au méso-centre. Plus d'information sur ces compilateurs ici.

Pour accéder ces compilateurs, il faut charger le module de la versions que vous souhaitez utiliser :

module load pgi/pgi19

Les commandes pour les principaux compilateurs sont les suivantes :

Les compilateurs PGI 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

pgcc 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 pgi/pgi19

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 PGI permettent d'utiliser des directives OpenACC afin de faire tourner les codes sur GPU.

Voici un exemple de code utilisant 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;
}

Pour le compiler :

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

Voici un script de soumission pour l'exécuter sur une machine GPU :

#! /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 pgi/pgi19

./saxpy

VERSIONS ET SCRIPTS D'INSTALLATION

TAGS