Utilisation avancée des processeurs graphiques avec Qt

Utilisation avancée des processeurs graphiques avec Qt par Rémi Achard Guillaume Belz
5.0 - Introduction au GPU computing
La programmation sur GPU présente des difficultés spécifiques qui nécessite en général
des connaissances avancées en programmation parallèle. Son utilisation n'est pas
forcement triviale et elle n'est pas intéressante pour tous types de problématique. Une
mauvaise utilisation peut aboutir à des performances médiocres, voir plus mauvaises que
la version CPU.
On observe régulièrement des personnes qui souhaitent utiliser le calcul sur GPU pour
accélerer un algorithme qui est relativement couteux en terme de temps. Or, il apparait
souvent que les problèmes de performances proviennent avant tout d'un problème de
choix conceptuel et non d'une limitation des capacités du CPU. Et, il apparait souvent
aussi que le passage au calcul GPU n'améliore pas les performances dans ce cas : le
problème se situe bien en amont de l'implémentation et le recourt au GPU ne corrigera
pas le problème.
Il est donc nécessaire de bien comprendre les spécificités du GPU Computing, les
contraintes en terme de transfert de données, d'accès mémoire, de parallélisation des
tâches, etc. pour espérer obtenir une amélioration des performances.
Le calcul sur cartes graphiques (GPU Computing ou anciennement GPGPU pour General-Purpose Processing on
Graphics Processing Units) est une technique permettant de réaliser des calculs parallèles à l'aide de la carte
graphique. Partant du constat qu'un grand nombre de calculs habituellement reservés au CPU étaient facilement
parallélisables, les fabriquants de carte graphiques ont modifié l'architecture de leur puces et developpé des API
permettant aux développeurs de réaliser des calculs genériques sur carte graphique.
Plusieurs API sont nées, la plus connue étant probablement celle de NVIDIA : CUDA (pour Compute Unified Device
Architecture). AMD propose également une API dédiée au GPU computing : ATI Stream SDK. Dans ce tutoriel nous
allons utiliser une autre API proposée par le groupe Khronos (qui propose également OpenGL) : OpenCL (pour
Open Computing Language). Le travail du groupe Khronos consiste à proposer une API standard pour OpenCL,
multiplatforme et open-source, qui sera ensuite implémentée par les différents constructeurs de puces graphiques sur
différents types de processeurs parallèles (CPU multicores, GPU, Digital Signal Processor, Cell, etc). Cette API dérive
du C (version C89) mais les spécifications pour le portage C++ sont données dans OpenCL 1.1. Il est également
possible de regarder les sources de la version C++ pour voir comment est pris en charge la version C.
OpenCL définit un langage équivalent au C permettant d'exécuter du code sur des périphériques de calcul (CPU,
GPU, accélrateur, etc.) Le code à exécuter est envoyé au runtime OpenCL sous forme de chaîne de caractères char*.
Ce code est donc compilé à l'exécution (contrairement à CUDA par exemple, qui est compilé avant l'exécution). Cela
permet de gagner en flexibilité et en portabilité mais implique de prendre les précautions nécessaires pour que le
programme reste performant et robuste sur différentes plateformes. OpenCL accepte les modèles de parallélisation
des données et des tâches.
Pour présenter les notions de base du GPU Computing et d'OpenCL, nous allons introduire un nouvel exemple :
l'addition de deux vecteurs, qui sera repris tout au long de cette partie sur le GPU Computing.
5.0.1 - Le calcul parallèle
Observons le travail effectué par le processeur lorsque l'on additionne deux vecteurs. La méthode consiste à parcourir
les deux tableaux, d'additionner deux éléments entre eux puis de mettre le résultat dans un tableau résutlat. Le code
C++ est relativement simple :
#include
int main(int, char**)
{
// declarations
const int N = 100000;
std::vector v1(N);
- 55 -
http://gbelz.developpez.com/remi-achard/gpu-avance-avec-qt/modified/