Système embarqué 27 : La parallélisation sur GPU

Le GPU (« Graphic processor unit ») est un co-processeur embarqué dans un ordinateur qui permet de créer des images pour afficher sur un écran.

Les GPU modernes sont efficaces pour manipuler l’infographie et le traitement d’image.

Leur structure parallèle les rend plus efficaces que les unités centrales de traitement (CPU) à usage général pour les algorithmes qui traitent de gros blocs de données en parallèle.

Dans un ordinateur personnel, un GPU peut être présent sur une carte vidéo ou intégré sur la carte mère. Dans certains processeurs, ils sont intégrés à la matrice du processeur

Le GPU est un super processeur de donnée mais sa limite est le débit d’accès à la mémoire.

Sommaire masquer

1 Les GPU

2 Programmation GPU

2.1 Implementation du GPU

3 Programmation CUDA

3.1 Kernel = code des threads executés sur le GPU

Les GPU

Calcul haute performance :

Parallélisation sur les machines mutli-processeurs (Efficace sur machine à mémoire distribuée)
Noeud de calcul performant (processeurs mutli-core, many-core ou FPGA).

Les GPU ont tendance à se développer de plus en plus vers une architecture many core :

A l’origine, architecture dédiée par le rendu de volume (Pipeline Graphique (programmation en OpenGL))

Depuis 2006, architecture adaptée à la parallélisation de divers calculs scientifiques (CUDA : Common Unifed Device Architecture)

Programmation GPU

Avant la programmation CUDA, il y avait des pipelines graphiques :

Vertex Shader : c’est le sommet
Rasterization : Remplit les polygones de pixels
Fragment Shader : Remplir les textures pour avoir des valeurs.

Matériel	Logiciel	Exécution
Stream Processor (SP)	thread	séquentielle
Processsor SIMT	multi-thread	parallèle (SIMT)
Carte GPU	grille de thread (kernel)	parallèle (MIMD) mémoire centralisée
PC multi-carte	thread du PC hote via librairie pthread	parallèle (MIMD) mémoire distribuée

Avant la programmation CUDA, il y avait des pipelines graphiques :

Vertex Shader : c’est le sommet
Rasterization : Remplit les polygones de pixels
Fragment Shader : Remplir les textures pour avoir des valeurs.

Parallélisation de l’algorithme : nourrir en threads (plus en moins indépendants) le GPU

Implementation du GPU

Selon l’intensité arithmétique du code (puissance de calcul exploitée / débit des données), l’execution sera soit memory bound soit computation bound.
➲ optimisation du code portera alors soit sur les accès mémoire ou soit sur la complexité arithmétique

Programmation CUDA

Kernel = code des threads executés sur le GPU

__global__ void matrixMul_kernel( float* C, float* A, float* B,int matrix_size) {
float Csum ;
int ifirst ,jfirst ;
int i,j ;
ifirst =blockIdx.x*BLOCK_SIZE ;
jfirst =blockIdx.y*BLOCK_SIZE ;
i=ifirst +threadIdx.x ;
j=jfirst +threadIdx.y ;
for (k = 0 ; k < matrix_size ; k++)
Csum += A[i][k] * B[k][j] ;
C[i][j] = Csum ;
}