Accueil🇫🇷Chercher

Compute Unified Device Architecture

CUDA (initialement l'acronyme de Compute Unified Device Architecture[2]) est une technologie de GPGPU (General-Purpose Computing on Graphics Processing Units), c'est-à-dire utilisant un processeur graphique (GPU) pour exécuter des calculs généraux à la place du processeur central (CPU). En effet, ces processeurs comportent couramment de l'ordre d'un millier de circuits de calcul fonctionnant typiquement à GHz, ce qui représente un potentiel très supérieur à un processeur central à GHz, fût-il multicœurs et multi-threads. Cette utilisation requiert que le calcul à effectuer soit parallélisable.

Compute Unified Device Architecture

Schéma de principe de l'architecture CUDA

CUDA permet de programmer des GPU en C++. Elle est développée par Nvidia, initialement pour ses cartes graphiques GeForce 8 Series, et utilise un pilote unifié utilisant une technique de streaming (flux continu).

Le premier kit de développement pour CUDA est publié le [3].

Applications

Est réalisable en CUDA tout ce qui demande du calcul intensif maillable en deux ou trois dimensions, ainsi que ce qui est décomposable en calculs indépendants sur des facteurs premiers, tel que cassage de codes, cassage de mot de passe[4], calculs de structures, simulation de fluides, algorithmes de recuit simulé, calculs économétriques sur de très grandes matrices (des techniques de découpages de ces matrices en blocs permettent de largement en paralléliser le produit).

Architectures reconnues par CUDA

Architecture Tesla

L'architecture Tesla, qui offre selon Nvidia la puissance de calcul d'un superordinateur (4 tĂ©raflops en simple prĂ©cision, 80 gigaflops en double prĂ©cision) pour une somme de 10 000 dollars, est construite sur CUDA.

Architecture Pascal

L'architecture Pascal, introduite en 2016 avec les cartes GTX1080 et GTX1070 Ă  2560 cĹ“urs (gravure en 16 nm) et qui utilise de la GDDR5X surcadençable Ă  2,1 GHz, est Ă©galement utilisable avec CUDA. NVidia lui annonce 11 tĂ©raflops en simple prĂ©cision.

Architecture Fermi (obsolète)

L'architecture Fermi, introduite en 2010 avec le GF100, est maintenant obsolète, les versions de CUDA ultérieures aux versions 8.0.x ne la prenant pas en charge.

Programmation

CUDA présente plusieurs particularités par rapport à la programmation en C, en proposant d'effectuer des calculs génériques sur GPU :

  • hiĂ©rarchisation explicite des zones de mĂ©moire (privĂ©e, locale, globale) permettant d'organiser finement les transferts entre elles ;
  • regroupement des threads en grilles de grilles : grille 1D, 2D ou 3D locale de threads pouvant se partager rapidement la mĂ©moire locale. Les grilles locales sont ordonnĂ©es en grille globale permettant d'accĂ©der Ă  la mĂ©moire globale.

Quelques réalisations combinent l'usage du langage Go, très orienté sur la programmation de processus concurrents et la gestion de mémoire sans fuites, avec celui de CUDA[5].

Avantages

  • Accès relativement standardisĂ© Ă  la puissance de calcul.
  • Un programme rĂ©alisĂ© avec CUDA reste utilisable sur plus d'une gĂ©nĂ©ration de matĂ©riel.

Limites

  • Les vitesses de transfert entre l'hĂ´te et le client peuvent ĂŞtre un goulet d'Ă©tranglement ; il peut ĂŞtre Ă©vitĂ© par des copies asynchrones.
  • Regroupement des threads par groupe de trente-deux, pour des questions de performances (les warps). Les divergences au sein d'un warp, dues aux exĂ©cutions conditionnelles, peuvent nuire grandement aux performances. Il s'agit d'une limitation due au modèle SIMD. De ce fait, tous les algorithmes ne gagnent pas Ă  ĂŞtre portĂ©s sur CUDA, et plus gĂ©nĂ©ralement sur un modèle SIMD.
  • Un code C valide peut ĂŞtre rejetĂ© Ă  cause des contraintes matĂ©rielles, telles que le manque de mĂ©moire ou le nombre de threads.
  • Les premières versions (1.x) de CUDA ne supportent pas la rĂ©cursion, les pointeurs de fonctions, et d'autres limites qui tendent Ă  disparaĂ®tre.
  • La prĂ©cision des calculs : la double-prĂ©cision n'est disponible que depuis la version 1.3. De plus, la norme IEEE 754 n'est que partiellement atteinte : en double prĂ©cision, le seul mode d'arrondi est round-to-nearest-even. En simple prĂ©cision, les nombres ne sont pas dĂ©normalisĂ©s, le signal NaN est absent, et les deux seuls modes d'arrondi sont chop et round-to-nearest even.

Exemples

Exemple avec Ă©mulation de carte

#include <stdio.h>
#include <stdlib.h>
#include <cuda.h>
#include <cuda_runtime.h>
__global__
void mykernel(float *A1, float *A2, float *R)
{
    int p = threadIdx.x;
    R[p] = A1[p] + A2[p];
}
int main()
{
    float A1[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    float A2[] = { 10, 20, 30, 40, 50, 60, 70, 80, 90 };
    float R[9];
    // 9 additions, aucune boucle !
    mykernel<<<1 ,9>>>(A1, A2, R);
    // sortie Ă  l'ecran
    for (int i = 0; i < 9; i++) {
        printf("%f\n", R[i]);
    }
}

Cet exemple fonctionne seulement si on émule la carte graphique car on ne recopie pas les données sur la carte.

Compilation par :

nvcc -deviceemu -o run prog.cu

Exemple avec une carte graphique NVidia

#include <stdio.h>
#include <stdlib.h>
#include <cuda.h>
#include <cuda_runtime.h>
__global__
void mykernel(float *A1, float *A2, float *R)
{
    int p = threadIdx.x;
    R[p] = A1[p] + A2[p];
}
 
int main()
{
    float A1[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    float A2[] = { 10, 20, 30, 40, 50, 60, 70, 80, 90 };
    float R[9];
    int taille_mem = sizeof(float) * 9;
    // on alloue de la memoire sur la carte graphique
    float *a1_device;
    float *a2_device;
    float *r_device;
    cudaMalloc((void**) &a1_device, taille_mem);
    cudaMalloc((void**) &a2_device, taille_mem);
    cudaMalloc((void**) &r_device, taille_mem);
    // on copie les donnees sur la carte
    cudaMemcpy(a1_device, A1, taille_mem, cudaMemcpyHostToDevice);
    cudaMemcpy(a2_device, A2, taille_mem, cudaMemcpyHostToDevice);
        
    //9 additions, aucune boucle !
    mykernel<<<1, 9>>>(a1_device, a2_device, r_device);
 	
    // on recupere le resultat
    cudaMemcpy(R, r_device, taille_mem, cudaMemcpyDeviceToHost);
    // sortie Ă  l'ecran
    for(int i = 0; i < 9; i++) {
        printf("%f\n", R[i]);
    }
}

Compilation par :

nvcc -o add_cuda add_cuda.cu

Notes et références

  1. « CUDA 12.2 Release Notes » (consulté le )
  2. (en) Anand Lal Shimpi et Wilson, Derek, « Nvidia's GeForce 8800 (G80): GPUs Re-architected for DirectX 10 », AnandTech, (consulté le ).
  3. (en) « http://news.developer.nvidia.com/2007/02/cuda_for_gpu_co.html »(Archive.org • Wikiwix • Archive.is • Google • Que faire ?), sur Nvidia.
  4. « Cryptohaze », sur SourceForge (consulté le ).
  5. https://hpcugent.github.io/easybuild/files/FOSDEM14/FOSDEM14_HPC_devroom_14_GoCUDA.pdf

Voir aussi

Articles connexes

Produits concurrents

Installation de CUDA en fonction des systèmes d'exploitation

Architecture CUDA

Cet article est issu de wikipedia. Text licence: CC BY-SA 4.0, Des conditions supplémentaires peuvent s’appliquer aux fichiers multimédias.