• Partagez
  • E-mail
  • Intégrer
  • J'aime
  • Télécharger
  • Contenu privé
Programmation sur GPU avec CUDA
 

Programmation sur GPU avec CUDA

on

  • 7,008 vues

 

Statistiques

Vues

Total des vues
7,008
Vues sur SlideShare
5,641
Vues externes
1,367

Actions

J'aime
3
Téléchargements
0
Commentaires
0

2 Ajouts 1,367

http://blog.infine.com 1366
http://sci-hub.org 1

Accessibilité

Catégories

Détails de l'import

Uploaded via as Microsoft PowerPoint

Droits d'utilisation

© Tous droits réservés

Report content

Signalé comme inapproprié Signaler comme inapproprié
Signaler comme inapproprié

Indiquez la raison pour laquelle vous avez signalé cette présentation comme n'étant pas appropriée.

Annuler
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Votre message apparaîtra ici
    Processing...
Poster un commentaire
Modifier votre commentaire

    Programmation sur GPU avec CUDA Programmation sur GPU avec CUDA Presentation Transcript

    • Programmation parallèle sur GPU avec CUDA par Maxime Fromentin Consultant In Fine Consulting le 26/04/2011
    • SOMMAIRE
      • Introduction sur les GPUs, CUDA et les domaines d’application
      • Explication plus technique sur CUDA, présentation d’un exemple
      • Questions
      • PARTIE I : Introduction aux GPUS et CUDA
    • GPU | DÉFINITION Déf: 1) Hardware spécialisé dans le rendu graphique 2) Microprocesseur présent sur les cartes graphiques au sein d’un ordinateur ou d’une console de jeux vidéo
      • Principaux constructeurs : NVIDIA, ATI/AMD, Intel Corporation
      • Différence avec les CPUs :
        • Hardware spécialisé dans le rendu graphique
        • Designer pour supporter un parallélisme de masse
        • Créer autant de threads que possible!
    • GPU | ÉVOLUTION DES PERFORMANCES
      • Les GPU sont des circuits massivement parallèles
        • Des centaines de cœurs
        • Des milliers de threads
      Floating-Point Operations per Second entre GPU et CPU
    • GPU | COMPARAISON DES ARCHITECTURES G80 GT200 Fermi Transistors 681 millions 1,4 milliards 3,0 milliards CUDA cores 128 240 512 Double précision (par cycle) - 30 FMA 256 FMA Simple précision (par cycle) 128 MAD 240 MAD 512 FMA Special Function Units (par SM) 2 2 4 Warp scheduler (par SM) 1 1 2 Shared memory (par SM) 16 Ko 16 Ko 48 Ko ou 16 Ko Cache L1 (par SM) - - 48 Ko ou 16 Ko Cache L2 - - 768 Ko Mémoire ECC Non Non Oui Kernels concurrents Non Non jusqu’à 16 Adresses 32 bits 32 bits 64 bits
    • CUDA | DÉFINITION
      • Avec l’évolution des performances, les GPUs deviennent programmables
      • CUDA – Compute Unified Architecture
        • Framework et ensemble d’outils qui permettent le design, l’implémentation et la vérification des applications GPUs
        • Extension du langage C
        • Toolkit incluant un compilateur spécialisé:
          • nvcc : méta-compilateur
          • distribue la compilation entre le CPU natif et le GPU
      CUDA Application Source file: C/C++ (.cpp) Source file: CUDA (.cu) Compiling: Visual C++ Compiling: nvcc Linking: Visual C++ Executable
    • CUDA | DÉFINITION
      • Plus de 200 millions de périphériques sont capables d’exécuter des applications CUDA !
      Des performances entre 5X et 100X supérieures aux CPUs !
    • CUDA ET FINANCE Plus à voir sur : http://www.nvidia.fr/object/cuda_app_tesla_fr.html
      • SciFinance :
      • “ By harnessing the power of NVIDIA GPUs, SciFinance parallel codes for Monte Carlo pricing models run blazingly fast: up to 50x-300x faster than serial code.”
      • PARTIE II : CUDA more in-depth
      • Exemple
    • CUDA | ORGANISATION DES THREADS
      • Les threads sont organisées dans une hiérarchie à 2 niveaux :
        • Grille
        • Blocs
      • Coordonnées uniques
        • Indices de bloc : 2D
        • Indices de thread : 3D
      • Tous les blocs d’une grille ont les même dimensions
      • Une grille par kernel
    • CUDA | ORGANISATION DES THREADS
      • blockIdx.x et blockIdx.y permet d’identifier le bloc
      • La grille comprend gridDim.x x gridDim.y blocs
      • threadIdx.x , threadIdx.y , threadIdx.z permettent
      • d’identifier le thread à l’intérieur d’un bloc
      • Plusieurs contraintes à prendre en compte:
        • Maximum sur les coordonnées
          • Grille (65536 x 65536)
          • Bloc (512, 512, 64)
        • Nombre de threads par SM
          • Maximum = 512
          • Typiquement 256
    • CUDA | EXÉCUTION DES THREADS
      • Par groupe de 32 (warp)
      • Tous les threads d’un warp exécutent la même instruction !
        • Si dans if/then/else, un thread du warp prend une autre branche que le reste du groupe, tout le groupe exécute les 2 branches ! (on utilise des predicated instructions pour ne pas stocker les résultats pour les threads concernées).
          • DIVERGENCE
          • Perte de performance
    • CUDA | MODÈLE D’EXÉCUTION
    • CUDA | STRUCTURE D’UN PROGRAMME
      • Un programme CUDA comprend :
        • Des phases s’exécutant sur l’hôte (CPU)
          • Phases séquentielles, entrées/sorties (interactions avec le système d’exploitation)
        • Des phases s’exécutant sur le(s) device (s) (GPU)
          • Parallélisme sur les données
       Limiter les interactions entres CPU et GPU pour augmenter les performances
    • CUDA | STRUCTURE D’UN PROGRAMME // allocation de la mémoire sur le device cudaMalloc((void**)a_d, size); … // transfert des données du CPU vers le device (GPU) cudaMemcpy(a_d, a, size, cudaMemcpyHostToDevice); … // appel du kernel (programme qui tourne sur le GPU) addVectors<<< xxx, xxx>>>(n, a_d, b_d, c_d); // récupération du résultat cudaMemcpy(c, c_d, size, cudaMemcpyDeviceToHost);
    • CUDA | EXEMPLE : MULTIPLICATION DE MATRICES
      • A, B, C sont carrées n x n
      • C = A * B
      Code séquentiel en c++ void matmul(int n, float* a, float*b, float* c) { for (int i=0; i<n, i++) { for (int j=0; j<n; j++) { float s = 0; for (int k=0; k<n; k++) s += a[i*n+k] * b[i*k+j]; c[i*n+j] = s; } } }
    • CUDA | EXEMPLE : MULTIPLICATION DE MATRICES
    • CUDA | EXEMPLE : MULTIPLICATION DE MATRICES … cudaMemcpy(xd, x, size, cudaMemcpyHostToDevice); cudaMemcpy(yd, y, size, cudaMemcpyHostToDevice); const int threadsPerBlock = 16; int nblocks = (n + threadsPerBlock - 1) / (threadsPerBlock); dim3 dimGrid(nblocks,nblocks,1); dim3 dimBlock(threadsPerBlock,threadsPerBlock,1); multMatKernel<<<dimGrid, dimBlock>>>(n, xd, yd, zd); cudaMemcpy(z, zd, size, cudaMemcpyDeviceToHost); //std::cout << x[0] << &quot; + &quot; << y[0] << &quot; = &quot; << z[0] << std::endl; cudaFree(xd); cudaFree(yd); cudaFree(zd);
    • CUDA | EXEMPLE : MULTIPLICATION DE MATRICES __global__ void multMatKernel(int n, float *x, float *y, float *z) { int xx= blockIdx.x * blockDim.x + threadIdx.x; int yy= blockIdx.y * blockDim.y + threadIdx.y; if(xx<n && yy <n) { float res =0.0f; for(int i=0;i<n;i++) res+=x[yy+n*i]*y[xx*n+i]; z[xx*n+yy] =res; } }  Des optimisations encore possibles en utilisant la mémoire locale
    • CONCLUSION
      • Avantages:
        • Des performances entre 5X et 100X supérieures au CPU
        • Une prise en main dans le domaine scientifique et de l’industrie
        • Prix inférieurs à un cluster!
        • Moins de place requise
      • Inconvénients:
        • Une prise en main plus difficile
        • Des optimisations plus compliquées à entreprendre (algorithme, mémoire,…)
        • et changeantes avec les versions de GPU.
    • BIBLIOGRAPHIE
      • Site CUDA:
      • http://www.nvidia.fr/object/cuda_home_new_fr.html
      • Exemples CUDA à télécharger:
      • http://developer.download.nvidia.com/compute/cuda/1.1-Beta/x86_website/Computational_Finance.html
      • SciFinance
      •  http://www.scicomp.com/
      • Projet de parallélisation automatique:
      • http://www.hpc-project.com/
      • Article: Binomial option pricing model
      •  http://developer.download.nvidia.com/compute/cuda/1_1/Website/projects/binomialOptions/doc/binomialOptions.pdf
      • Blog In Fine Consulting
      • http://blog.infine.com/
    • QUESTIONS?