Calcul performant sur Applications en : Accélération d un algorithme d Inpainting pour le calcul P. Kestener Y. Moudden CEA-Saclay, IRFU, SEDI, France Service d Electronique, Informatique et Détecteurs Séminaire Sieste, Ens Lyon, 3 mars 2009 Inpainting sur 1 / 45
Au menu... Quelques thèmes de recherche à IRFU Introduction au Computing, calcul sur processeur graphique Application en : Inpainting (interpolation de données manquantes) Notion de représentation parcimonieuse Implantation de transformée en ondelettes pour le calcul Inpainting sur 2 / 45
Sommaire pour le calcul Inpainting sur pour le calcul Inpainting sur 3 / 45
IRFU (Institut de recherche sur les lois fondamentales de l Univers) pour le calcul Inpainting sur 4 / 45
IRFU (Institut de recherche sur les lois fondamentales de l Univers) pour le calcul Inpainting sur 5 / 45
COAST (COmputational ASTrophysics at Saclay) Projet de simulations numériques massivement parallèles pour l (resp. et technique : R. Teyssier et B. Thooris) http://irfu.cea.fr/projets/coast/ développement de méthodes numériques implantation logicielle, optimisation et parallélisation développement d outils de visualisation et bases de données Moyens de calcul : locaux : cluster 256 processeurs Opteron, mémoire de 8GBytes/coeur nationaux : PLATINE, CEA/CCRT, 10000 coeurs Itanimum2@1.6GHz, 50 TFlops nationaux : BABEL, CNRS/IDRIS, BlueGene, 40000 coeurs PPC, 110 TFlops futur : CEA, GENCI-CINES, combinaison CPU/, 10000 Xeon-quad et 48 boites Tesla S1070 (4 ) : 128+200 TFlops pour le calcul Inpainting sur 6 / 45
CEA Cluster hybride CPU/, début 2009 pour le calcul Inpainting sur 7 / 45
COAST (COmputational ASTrophysics at Saclay) Quelques codes développés à Saclay : pour le calcul Inpainting sur Ï Ï Ï Ï RAMSES, R. Teyssier et al. : simulation de fluides autogravitants (hydrodynamique3d+mhd+n-corps, raffinement de grille adaptatif ) pour l étude des structures aux grandes échelles et la formation des galaxies, record de simulation N-corps en 2007 (70 milliards de particules) HERACLES, E. Audit et al. : étude du milieu interstellaire (hydrodynamique et transfert radiatif ) ASH, A. S. Brun et al. : code de magnétohydrodynamique en géométrie sphérique (intérieur du Soleil) JUPITER, F. Massey et al. : étude des disques protoplanétaires et forces de marées disque/planète (hydrodynamique 3D, grille adaptative) 8 / 45
Sommaire pour le calcul Inpainting sur pour le calcul Inpainting sur 9 / 45
Mini historique : 1995 à 1999 pour le calcul Inpainting sur fonction initiale : décharger le CPU de toutes les tâches graphiques matériel dédié pour des tâches spécialisées notion de pipeline graphique 2D puis 3D à partir de 1995 : rendu 3D, fonction de rasterisation (image vectorielle vers image matricielle) et rendu plus complexes 10 / 45
Mini historique : 1995 à 1999 pour le calcul Inpainting sur spécification de standards d interface de programmation (API) pour les pipelines graphiques : OpenGL, DirectX essor du 3D grand public (Toy Story chez Pixar, console de jeux) 1999 : transfert vers les des opérations de transformation (multiplication matrice 4x4) et éclairage 11 / 45
Mini historique : 2000 et après pipeline graphique programmable : les pixel et vertex-shaders écrit en langage bas-niveau, avantage : plus grande flexibilité et permettre au matériel de suivre les évolutions rapides des standards, programmation plus facile et plus rapide. : Vertex Processors (MIMD), Fragment Processors (SIMD), float 32bits introduction de langages haut-niveau : Cg, GLSL (OpenGl Shading Langage) abstraction du matériel, le programmeur n a besoin de connaître que peu d information sur le matériel pour le calcul Inpainting sur 12 / 45
computing GP : General Purpose computions on Nvidia Geforce8800, 2006, vers une architecture unifiée (on fusionne les différents type de shaders processors) CUDA : Compute Unified Device Architecture CUDA SDK (compilateur+librairies) pour le GP, language C-like Applications à l étude : météo : http://www.mmm.ucar.edu/wrf/wg2// chimie quantique : http://pubs.acs.org/doi/abs/10.1021/jp0776762 dynamique moléculaire (problèmes à N corps): http://www.ks.uiuc.edu/research/gpu/ analyse finançière : http://www.oneye.com.au/downloads/oneye-options-v1.pdf traitement du signal et de l image : -CV https: //picoforge.int-evry.fr/cgi-bin/twiki/view/gpucv/web/ pour le calcul Inpainting sur géophysique 13 / 45
computing Serveur dédié au Computing pour le calcul Inpainting sur gain en performance gain en consommation électrique fiabilité??? http://gpgpu.univ-perp.fr/images/3/36/ _Reliability_2008.pdf 14 / 45
Architecture Matérielle Nvidia CUDA / G80 cours CUDA : http://courses.ece.uiuc.edu/ece498/al/syllabus.html pour le calcul Inpainting sur 16 multi-processeurs (8 SIMD thread processor/multi-processeur) différents types de mémoire on-chip (locale, partagée, texture, constant) et off-chip la mémoire globale. 15 / 45
CUDA (Modèle d exécution et programmation) écrire un programme pour un pixel thread instantier ce programme sur beaucoup de threads en parallèle grille indexée de blocs de threads : threadidx et blockidx (built-in variables) threads d un même bloc ont accès à un espace de mémoire partagée les blocs sont indépendants, pas de synchronisation, execution dans un ordre indéfini pour le calcul Inpainting sur 16 / 45
CUDA Programmation en C modificateurs de déclaration global void KernelFunc(...); // kernel callable from host device void DeviceFunc(...); // function callable on device device int GlobalVar; // variable in device memory shared int SharedVar; // shared in PDC by thread block mots clés : indexes threadidx, blockidx invocation de fonction en spécifiant les nombre de bloc et threads/bloc pour le calcul Inpainting sur KernelFunc<<<500, 128>>>(...); // launch 500 blocks w/ 128 threads each synchronisation des threads d un même bloc syncthreads(); // barrier synchronization within kernel routines spécifiques inspirées de la libc (ex: allocation mémoire, transfert de données entre les mémoires globales du CPU et du,...) 17 / 45
CUDA Programmation en C : exemple exemple : addition de vecteur // Compute vector sum C = A+B // Each thread performs one pair-wise addition global void vecadd(float* A, float* B, float* C) { int i = threadidx.x + blockdim.x * blockidx.x; C[i] = A[i] + B[i]; } invocation void main() { // allocate device () memory float* d_a, d_b, d_c; cudamalloc( (void**) &d_a, N * sizeof(float)); cudamalloc( (void**) &d_b, N * sizeof(float)); cudamalloc( (void**) &d_c, N * sizeof(float)); // copy host memory to device cudamemcpy( d_a, h_a, N * sizeof(float),cudamemcpyhosttodevice); cudamemcpy( d_b, h_b, N * sizeof(float),cudamemcpyhosttodevice); // Execute on N/256 blocks of 256 threads each vecadd<<< N/256, 256>>>(d_A, d_b, d_c); } pour le calcul Inpainting sur 18 / 45
Optimisations CUDA Un programme CUDA doit prendre en compte les contraintes suivantes Accès coelescent en mémoire globale : des threads d indexes consécutifs doivent accéder à des cases mémoires d addresse consécutives, problème d alignement Utiliser la mémoire partagée (bien meilleure bande passante que la mémoire globale) Utiliser efficacement le parallélisme Garder le occupé un maximun de temps avoir un rapport calcul / accès mémoire élevé Utiliser au mieux la hiérarchie de threads. Tenir compte des conflits de banc mémoire pour le calcul Inpainting sur 19 / 45
Sommaire pour le calcul Inpainting sur pour le calcul Inpainting sur 20 / 45
Motivations pour le calcul pour l, démonstrateur de l utilisabilité/efficacité des pour le et spécialement les algorithmes qui peuvent être gourmands en resources et temps de calcul, exemple sur les algorithmes d Inpainting ou interpolation de données manquantes. Bon candidat pour l implantation, algorithme itératif. Inpainting sur 21 / 45
Pourquoi et Comment remplir des trous! Pourquoi? enlever des artefacts sur des photos numérisées enlever du texte en sur-impression sur une image remplir des trous à la suite d une transmission mauvaise ou partielle de données meilleur sur-échantillonage en vue d une compression Comment? interpolation pas satisfaisante bien des méthodes : EDP, variationnelle,... Utilisation de la notion de représentation creuse ou parcimonieuse de données (ou sparsity en anglais) idée utilisée pour la compression d image par codage par transformation: Jpeg utilise la DCT, JPEG2000 les ondelettes (CDF97). pour le calcul Inpainting sur 22 / 45
Représentation creuse et remplissage de trous! Un trou induit beaucoup de petits coefficients. Inpainting = méthode itérative basée sur le seuillage des petits coefficients pour reconstruire au mieux une approximation du signal de départ. pour le calcul Inpainting sur 23 / 45
Représentation creuse et remplissage de trous! Un trou induit beaucoup de petits coefficients. Inpainting = méthode itérative basée sur le seuillage des petits coefficients pour reconstruire au mieux une approximation du signal de départ. pour le calcul Inpainting sur 24 / 45
Représentation creuse et remplissage de trous! Un trou induit beaucoup de petits coefficients. Inpainting = méthode itérative basée sur le seuillage des petits coefficients pour reconstruire au mieux une approximation du signal de départ. pour le calcul Inpainting sur 25 / 45
Représentation creuse et remplissage de trous! Un trou induit beaucoup de petits coefficients. Inpainting = méthode itérative basée sur le seuillage des petits coefficients pour reconstruire au mieux une approximation du signal de départ. pour le calcul Require: K,n N, image in, image out Require: K,n N, residu, image DCT, mask Require: s min,s max N δ s = (s max s min )/K, s = s max for i = 0 to K do residu = image in image out image DCT = DCT(image out + mask residu) image DCT = image DCT (abs(image DCT ) >= s) image out = DCT 1 (image DCT ) s = δ s end for return image out Inpainting sur 26 / 45
Exemples d application de Inpainting appliquée à une image dont 80% des pixels ont été mis à zéro: pour le calcul Inpainting sur 27 / 45
Inpainting en Mission Planck 1 (2009): cartographie du fond diffus cosmologique (CMB) masquer les radio-sources du plan galactique qui polluent l analyse des données du CMB (mesure de non-gaussianités, de spectre de puissance, autres mesures statistiques non-locales) et restorer la stationarité résultat d inpainting des données CMB (WMAP) par l algorithme MCA sur la sphère 2 : pour le calcul Inpainting sur 1 http://planck.esa.int 2 P. Abrial et al., Journal of Fourier Analysis and Applications (JFAA), special issue on Analysis on the Sphere, 13, 6, pp 729-748, 2007. 28 / 45
Sommaire pour le calcul Inpainting sur pour le calcul Inpainting sur 29 / 45
La Transformée en ondelettes discrète (Lifting scheme) Bases d ondelettes biorthogonales 1D: f (t) = j,n Z < f,ψ j,n > ψ j,n(t) ψ j,n (t) = 1 a j ψ( t a j n) pour le calcul Inpainting sur Ondelette CDF97, reconstruction exacte. 30 / 45
La Transformée en ondelettes discrète (Lifting scheme) Bases d ondelettes biorthogonales 1D: f (t) = j,n Z < f,ψ j,n > ψ j,n(t) ψ j,n (t) = 1 a j ψ( t a j n) pour le calcul Inpainting sur Ondelette CDF97, reconstruction exacte. 31 / 45
Opérateur Transformée en ondelettes CDF53 CPU void cdf53_1d_row_cpu(float *out, float* in, int scale) { float a; // Predict 1 a=-0.5; for (int i=1;i<scale-2;i+=2) in[i]+=a*(in[i-1]+in[i+1]); in[scale-1]+=2*a*in[scale-2]; // Update 1 a=0.25; for (int i=2;i<scale;i+=2) in[i]+=a*(in[i-1]+in[i+1]); in[0]+=2*a*in[1]; // Scale data and out a=m_sqrt2; for (int i=0;i<scale/2;i++) { out[i]=in[2*i]/a; out[scale/2+i]=in[2*i+1]*a; } } pour le calcul Inpainting sur 32 / 45
Opérateur(s) CDF53 sur avec CUDA pour le calcul code CDF53, signal de taille s 512, kernel entièrement en mémoire partagée (1 bloc de N threads par ligne, N est le paramètre d échelle), code CDF53, signal de taille s > 512, image découpée en morceaux (à la façon de l exemple "Convolution Séparable" du SDK Cuda pour la gestion des effets bords); implantation de kernel avec retour en mémoire globale intermédiaire. Tous les kernel sont coalescents en lecture/écriture. Inpainting sur 33 / 45
Opérateur(s) CDF53 sur avec CUDA : mémoire partagée global void cdf53_1d_row_sm_kernel(float *data, const int size_x, int scale) { shared float shared[block_dim]; const int x = threadidx.x; unsigned int index = size_x*y + x; shared[x] = data[index]; syncthreads(); const int y = blockdim.y; pour le calcul Inpainting sur if((x < scale) && (y < scale)){ // Predict 1 if(x<scale/2-1) shared[2*x+1] -= 0.5*(shared[2*x]+shared[2*x+2]); if (x == scale/2-1) shared[scale-1] -= shared[scale-2]; syncthreads(); // Update 1 if(x<scale/2 && x>0) shared[2*x] += 0.25*(shared[2*x-1]+shared[2*x+1]); if (x == 0) shared[0] += 0.5*shared[1]; syncthreads(); // Scale and Pack back to global memory const float a = M_SQRT2; if(x < scale/2) data[index] = shared[2*x]/a; else data[index] = shared[2*x-scale+1]*a; } } 34 / 45
Opérateur(s) CDF53 sur avec CUDA : par morceaux Découpage en morceaux (à la Convolution Séparable ): Implantation complète: for (int scale = DATA_W; scale >lowestscale; scale >>= 1) { if (scale > scaletransition) { // scale > 512 blockgridrows.x = idivup(scale, ROW_TILE_W); blockgridrows.y = scale; blockgridcols.x = idivup(scale, COLUMN_TILE_W); blockgridcols.y = idivup(scale, COLUMN_TILE_H); cdf53row(d_datab, d_dataa, DATA_W, DATA_H, scale, scale, gridrows, threadrows, gridpack, threadpack); cdf53col(d_datab, d_dataa, DATA_W, DATA_H, scale, scale, bridcols, threadcols, gridpack, threadpack); } else { // use the shared memory version grid_row.y = threads_row.x = scale; grid_col.x = threads_col.y = scale; cdf53 predict pour le calcul Inpainting sur cdf53_1d_row_sharedmem_kernel<<< grid_row, threads_row>>>(d_dataa,data_w,scale) cdf53_1d_col_sharedmem_kernel<<< grid_col, threads_col>>>(d_dataa,data_w,scale) } } 35 / 45
CDF97 / CUDA performances Différentes implantations utilisées sur CPU/ d une transformée CDF97 2d : Matlab : http: //www.math.ucla.edu/~getreuer/waveletcdf97.html implantation naïve en C dérivée de http://www.ebi.ac.uk/~gpau/misc/dwt97.c 1 implantation optimisée en C utilisant les routines ippiwtfwdrow_d97_jpeg2k_32f_c1r et ippiwtfwdcol_d97_jpeg2k_32f_c1r de la librairie IPP d Intel (optimisées pour les instructions SIMD - SSE des processeurs Intel) 2 implantation CUDA originale 1 ce code a été modifié pour une transformation 2d en optimisant l allocation mémoire et en fusionant les opérations scale et pack 2 Intel Integrated Performance Primitives 6.0, with Intel compiler 11.0 sur cpu E6750@2.66GHz, 4Mb de cache, FSB 1.33GHz pour le calcul Inpainting sur 36 / 45
CDF97 / CUDA performances Temps de calcul 1 CDF97 2D sur 2 et CPU 3 (en ms) en fonction de la taille d image taille CPU Matlab CPU C CPU intel 4 CPU C CPU intel 64 3.2 0.12 0.08 0.06 2.1 1.3 128 10.2 0.46 0.26 0.08 5.0 3.2 256 41 1.8 1 0.23 8.0 4.3 512 175 12.9 4.8 0.84 15.3 5.7 1024 750 156 47.5 5.2 29.8 9.1 2048 3100 964 185 20.9 45.9 8.8 4096 12780 5062 770 81.5 59.9 9.4 Améliorations possibles de l implantation CUDA: aux petites échelles, regrouper plusieurs lignes dans un même bloc 1 temps de transfert de données non inclus 2 GTX8800, CUDA 2.0, driver 177.80 3 Intel Quad Q6600@2.4GHz, Ubuntu 8.10 4 Intel compiler, MKL, IPP -> optimisation SIMD/SSE pour le calcul Inpainting sur 37 / 45
Discrète (DCT) 2D X k1,k 2 = N 1 1 N 2 1 n 1 =0 n 2 =0 [ π x n1,n 2 cos (n 1 + 1 ] [ π N 1 2 )k 1 cos (n 2 + 1 ] N 2 2 )k 2 FFTW: CuFFT:, pas implanté. On peut décomposer l opérateur DCT direct en 3 étapes 3 : 1. pre-processing: permutation, for (i=0; i<n1/2; i++) { for (j=0; j<n2/2; j++) { out[j +N2*i ] = in[2*j +N2*2*i]; out[j+n2/2+n2*i ] = in[n2-1-2*j+n2*2*i]; out[j +N2*(i+N1/2)] = in[2*j +N2*(N1-1-2*i)]; out[j+n2/2+n2*(i+n1/2)] = in[n2-1-2*j+n2*(n1-1-2*i)]; } } 2. DFT(N1,N2), 3. recombinaison code. 3 John Makhoul, A fast cosine transform in one and two dimensions, IEEE Trans. Acoust. Speech Sig. Proc. 28 (1), 27-34 (1980). pour le calcul Inpainting sur 38 / 45
Discrète (DCT) 2D X k1,k 2 = N 1 1 N 2 1 n 1 =0 n 2 =0 [ π x n1,n 2 cos (n 1 + 1 ] [ π N 1 2 )k 1 cos (n 2 + 1 ] N 2 2 )k 2 FFTW: CuFFT:, pas implanté. On peut décomposer l opérateur DCT direct en 3 étapes 3 : 1. pre-processing: permutation, 2. DFT(N1,N2), 3. recombinaison code. pour le calcul Inpainting sur 3 John Makhoul, A fast cosine transform in one and two dimensions, IEEE Trans. Acoust. Speech Sig. Proc. 28 (1), 27-34 (1980). 39 / 45
Opérateur DCT direct sur avec CUDA Implantation du pre-processing (permutation) global void dct2dpreprocess(real *in, Complex *out, int width, int height){ int xindex = blockidx.x * BLOCK_DIM + threadidx.x; int yindex = blockidx.y * BLOCK_DIM + threadidx.y; if((xindex < width) && (yindex < height)) { int index_in = yindex * width + xindex; if (threadidx.x is even) xindex /= 2; else if (threadidx.y is even) yindex /= 2; else int index_out = yindex * width + xindex; out[index_out].x = in[index_in]; out[index_out].y = 0; } } xindex = (width-1-xindex)/2+width/2; pour le calcul Inpainting sur yindex = (height-1-yindex)/2+height/2; 40 / 45
DCT / CUDA performances Profiling de la DCT 2d directe (N = 1024 2 ) sur (GTX8800) versus CPU (Quad Q6600@2.4GHz) method=[ dct2dpreproc ] gputime=[ 680.992 ] occup.=[ 1.00 ] method=[ DFT ] gputime=[ 3321.376 ] occup.=[ 0.33 ] method=[ dct2dpostproc ] gputime=[ 1464.864 ] occup.=[ 0.33 ] pour le calcul Inpainting sur temps de calcul CPU(FFTW) / (CUDA): 48ms / 5.9ms, (accéleration 8.3) Les étapes de pre et post-processing représentent 40 % du temps de calcul ( 2ms) sur. tentative d optimiser le pre-processing pour rendre les accès en lecture et écriture coalescents: gain minime ( 10%) pour une compléxité nettement accrue du code. 41 / 45
DCT / CUDA performances Temps de calcul DCT2D sur 1 et CPU 2 (en ms) en fonction de la taille d image taille CPU accél /CPU 64 0.52 0.22 2.3 128 0.83 0.28 2.9 256 3.1 0.5 6.0 512 7.3 1.7 4.1 1024 48 5.9 8.3 2048 373 31.6 11.8 4096 1850 134 13.8 Améliorations possibles : écrire une implantation dédiée de la DCT utiliser une autre librairie de FFT sur 3 1 GTX8800 2 Intel Quad Q6600@2.4GHz 3 Govindaraju et al., High Performance Discrete Fourier Transforms on Graphics Processors, SuperComputing 2008, Austin. pour le calcul Inpainting sur 42 / 45
Performance de l inpainting par DCT / CDF sur problème traité : image de Lena avec 40 % de pixels mis à zéro, 50 itérations Temps de calcul complet d un inpainting par DCT2D sur et CPU (en ms) en fonction de la taille d image taille CPU accél /CPU 128 59 19 3.1 256 310 44 7.0 512 891 178 5.0 1024 5360 653 8.2 2048 48000 3390 14.1 pour le calcul Inpainting sur 43 / 45
Performance de l inpainting par DCT / CDF sur problème traité : image de Lena avec 40 % de pixels mis à zéro, 50 itérations Temps de calcul complet d un inpainting par TO-CDF97 toute échelle sur et CPU (en ms) en fonction de la taille d image taille CPU accél /CPU 256 255 53 4.8 512 1715 154 11.1 1024 17800 740 24.0 2048 140200 3130 44.5 pour le calcul Inpainting sur 44 / 45
Résultats pour le calcul Inpainting sur 45 / 45
Sommaire Codes de la DCT 2D Bibliographie Codes de la DCT 2D Bibliographie 46 / 45
Discrète (DCT) 2D Codes de la DCT 2D Bibliographie La permutation de pre-processing sur CPU: for (i=0; i<n1/2; i++) { for (j=0; j<n2/2; j++) { out[j +N2*i ] = in[2*j +N2*2*i]; } } out[j+n2/2+n2*i ] = in[n2-1-2*j+n2*2*i]; out[j +N2*(i+N1/2)] = in[2*j +N2*(N1-1-2*i)]; out[j+n2/2+n2*(i+n1/2)] = in[n2-1-2*j+n2*(n1-1-2*i)]; 47 / 45
Discrète (DCT) 2D L opération de post-processing sur CPU: for (i=0; i<n1; i++) { for (j=0; j<n2; j++) { retour Codes de la DCT 2D Bibliographie } } cos_a = cos(-m_pi*i/2/n1-m_pi*j/2/n2); sin_a = sin(-m_pi*i/2/n1-m_pi*j/2/n2); cos_b = cos(-m_pi*i/2/n1+m_pi*j/2/n2); sin_b = sin(-m_pi*i/2/n1+m_pi*j/2/n2); if (j==0) { datadct[n2*i] = datadft[n2*i].real()*cos_a - datadft[n2*i].imag()*sin_a; } else { datadct[j+n2*i] = 0.5*(dataDft[j+N2*i].real()*cos_adataDft[j+N2*i].imag()*sin_a+ datadft[n2-j+n2*i].real()*cos_bdatadft[n2-j+n2*i].imag()*sin_b); } 48 / 45
Discrète (DCT) 2D La permutation de pre-processing sur : global void dct2dpreprocess(real *in, Complex *out, int width, int height){ int xindex = blockidx.x * BLOCK_DIM + threadidx.x; int yindex = blockidx.y * BLOCK_DIM + threadidx.y; if((xindex < width) && (yindex < height)) { int index_in = yindex * width + xindex; if (threadidx.x == 2*(threadIdx.x/2)) xindex /= 2; else xindex = (width-1-xindex)/2+width/2; if (threadidx.y == 2*(threadIdx.y/2)) yindex /= 2; else yindex = (height-1-yindex)/2+height/2; Codes de la DCT 2D Bibliographie } } int index_out = yindex * width + xindex; out[index_out].x = in[index_in]; out[index_out].y = 0; 49 / 45
Discrète (DCT) 2D L opération de post-processing sur : global void dct2dpostprocess(complex * in, Real * out, int width, int height) { float real, real2, imag, imag2; float cos_a,sin_a,cos_b,sin_b; int yindex = blockidx.x * blockdim.x + threadidx.x; int xindex = blockidx.y * blockdim.y + threadidx.y; int index = yindex + height*xindex; int index2 = height-yindex+height*xindex; Codes de la DCT 2D Bibliographie if((xindex < width) && (yindex < height)) { cos_a = cos(-m_pi_2*xindex/width-m_pi_2*yindex/height); sin_a = sin(-m_pi_2*xindex/width-m_pi_2*yindex/height); cos_b = cos(-m_pi_2*xindex/width+m_pi_2*yindex/height); sin_b = sin(-m_pi_2*xindex/width+m_pi_2*yindex/height); real = in[index].x; imag = in[index].y; if (yindex==0) { out[height*xindex] = real*cos_a - imag*sin_a; } else { 50 / 45
Transformée en ondelettes 2D CDF53, kernel predict retour global void cdfrowpredict(...){ shared float data[kernel_radius + ROW_TILE_W + KERNEL_RADIUS]; //Current tile and apron limits, relative to row start const int tilestart = IMUL(blockIdx.x, ROW_TILE_W); const int tileend = tilestart + ROW_TILE_W - 1; const int apronstart = tilestart - KERNEL_RADIUS; const int apronend = tileend + KERNEL_RADIUS; //Clamp tile and apron limits by image borders const int tileendclamped = min(tileend, datawscale - 1); const int apronstartclamped = max(apronstart, 0); const int apronendclamped = min(apronend, datawscale - 1); //Row start index const int rowstart = IMUL(blockIdx.y, dataw); const int apronstartaligned = tilestart - KERNEL_RADIUS_ALIGNED; Codes de la DCT 2D Bibliographie const int loadpos = apronstartaligned + threadidx.x; if(loadpos >= apronstart){ const int smempos = loadpos - apronstart; data[smempos] = ((loadpos >= apronstartclamped) && (loadpos <= apronendclamped))? d_data[rowstart + loadpos] : 0; } syncthreads(); const int writepos = tilestart + threadidx.x; if(writepos <= tileendclamped && blockidx.y < datahscale){ const int smempos = writepos - apronstart; const int gmempos = rowstart + writepos; if ( gmempos!= 2*(gmemPos >> 1) && writepos < datawscale-2) data[smempos] += coef*(data[smempos-1]+data[smempos+1]); if ( writepos == (datawscale - 1) ) data[smempos] += 2*coef*data[smemPos-1]; if (writepos < datawscale) d_result[gmempos] = data[smempos]; 51 / 45
Backup sur Tesla Codes de la DCT 2D Bibliographie 52 / 45
Sommaire Codes de la DCT 2D Bibliographie Codes de la DCT 2D Bibliographie 53 / 45
Sur CUDA Codes de la DCT 2D liens et ressources pédagogiques sur CUDA : Bibliographie http://www.nvidia.com/object/cuda_university_ courses.html www.cse.unr.edu/~fredh/papers/thesis/023-crow/ Final.pdf Evolution of the Graphical Processing Unit, Thomas Scott Crow, University of Nevada, Master of Science, 2004. informatik.uibk.ac.at/teaching/ss2008/seminar/ gpu.pdf s - Graphics Processing Units, Minh Tri Do Dinh, Institute of Computer Science, University of Innsbruck. http: //courses.ece.uiuc.edu/ece498/al/syllabus.html Programming Massively Parallel Processor, ECE 498 AL, Illinois University 54 / 45