OpenCL / CUDA Tutorial

[sego]

Hallo,

ich möchte einen Algorithmus zwecks Parallelisierung gern mit CUDA oder OpenCL programmieren. Auf C steht er soweit, mich würde halt interessieren in wie weit sich da Performanceverbesserungen noch rausholen lassen. Nur finde ich keine gescheiten Tutorials. Kennt jm. zufällig welche? Da ich ne Geforce habe, spielts nicht so ne Rolle ob CUDA oder OpenCL, zumal das eh recht gleich sein soll ...

Grüße

sego

 

[darktrym]

Dir reichen die geschätzten Hundert Videos, PDF, Podcasts auf deren(NVIDIA) Seite nicht aus?
Hier mal ein kleines Beispiel für die Matrizenmultiplikation.

#include <stdio.h>
#include <stdlib.h>
#include <cuda.h>

#define DIM 2000
#define AMOUNT (DIM * DIM)
	
__global__ void MatMul(int *a, int *b, int *c) {
	int col = (blockIdx.x * blockDim.x) + threadIdx.x;
	int row = (blockIdx.y * blockDim.y) + threadIdx.y;
	/* calculate*/
	int sum = 0;
	int cnt;
	int offset = row * DIM;
	for(cnt = 0; cnt < DIM; cnt++) 
		sum += a[offset + cnt] * b[cnt * DIM + col];
	c[offset + col] = sum;
}

int main() {
	/* host matrices */
	int *h_a;
	int *h_b;
	int *h_c;
	/* device matrices*/
	int *d_a;
	int *d_b;
	int *d_c;
	int row;
	int offset;
	size_t size = AMOUNT * sizeof(int);
	
	/* create matrices*/
	h_a = (int*) malloc(sizeof(int) * AMOUNT);
	h_b = (int*) malloc(sizeof(int) * AMOUNT);
	h_c = (int*) malloc(sizeof(int) * AMOUNT); 
	cudaMalloc((void**) &d_a, sizeof(int) * AMOUNT);
	cudaMalloc((void**) &d_b, sizeof(int) * AMOUNT);
	cudaMalloc((void**) &d_c, sizeof(int) * AMOUNT);
	
	/* fill matrices*/
	for(row = 0; row < DIM; row++) 
		for(offset = row * DIM; offset < (row+1) * DIM; offset++) 			 
			h_a[offset] = h_b[offset] = rand() % 10;
	
	/* copy matrices from host to device */
	cudaMemcpy(d_a, h_a, size, cudaMemcpyHostToDevice);
	cudaMemcpy(d_b, h_b, size, cudaMemcpyHostToDevice);

	dim3 threadsPerBlock(18, 18); 
	dim3 numBlocks(DIM/threadsPerBlock.x, DIM/threadsPerBlock.y);
	MatMul<<<numBlocks, threadsPerBlock>>>(d_a, d_b, d_c);
	/* copy matrix from device to host */
	cudaMemcpy(h_c, d_c, size, cudaMemcpyDeviceToHost);
	
	/* free matrices */	
	cudaFree(d_a);
	cudaFree(d_b);
	cudaFree(d_c);
	free(h_a);
	free(h_b);
	free(h_c);
}

 

[pumpkin0]

mich würde halt interessieren in wie weit sich da Performanceverbesserungen noch rausholen lassen.

Erkläre den Algo und man kann dir helfen. Ohne weitere Informationen zum Algo ist alles weitere raten.

MfG,

 

[Army]

Hallo!!
bin ganz neu hier und ich versuche meine CUDA zu lernen
dabei hab ich viel schwierigkeit
ich möchte gern die mittelwert eine Threads berechnen.. ich komme damit nicht klar
könnte mir jemand eine so eine kode geben biiitte
danke

 

[Army]

Ich hab es nun allein versucht aber leider komm nur miss raus
hiiiiiiiillfe bitte

#include "cuda_runtime.h"
#include "device_launch_parameters.h"

#include <stdio.h>
#define anzahl 256



__global__ void MittelWert(float *result,  float *elt)
{
    int sum = 0 ;
    for(int i =0 ; i<anzahl; i++)
    {
       sum += elt[256*i+threadIdx.x];
    }
    sum/= anzahl;
    result[256*i+threadIdx.x] = sum ;
      
}




int main()
{

    int * dev_elt;
    int * dev_result;
    const float size = anzahl * anzahl * sizeof(float);
    
    cudaMalloc( (void**) & dev_elt, size);
    cudaMalloc( (void**) & dev_result, size);
    
    cudaMemcpy(dev_elt, elt, size, cudaMemcpyHostToDevice) ;
    
    MittelWert<<<1, anzahl>>>(dev_result, dev_elt);
    
    cudaMemcpy(dev_result, result, size, cudaMemcpyDeviceToHost);
    

    cudaFree ( dev_elt );
    cudaFree ( dev_result );
    
    
}

 

[Army]

Warum meldet sich Keine

 

[Army]

Hallo
ich versuche nochmal meine glück her

ich möchte der Mittewet eine array berechnen:
angenommen haben wir eine Array v1 mit 10000000 elemente
um der mittelwert in C zu berechnen, brauchen wir folgende Kode

// initializierung
int j ;
for (j=0; j <10000000; j++)
    {
      tab[j]=j;
   }

 // danach mittelwert berechnen
int i;
int somme =0;
int moy;
for (i=0; i <10000000; i++)
{ somme +=tab[i];}
moy /=10000000;

jetzt würde ich gern das ganz mit CUDA berechnen
dafür hab ich folgende Kode geschrieben

#include "cuda_runtime.h"
#include "device_launch_parameters.h"

#include <stdio.h>

/*
die function  MoyenneTab() sollte die mittelwet von array v1 berechnen und das ergebnis in array res speichern.
diese berechnung sollte wie folgende ablaufen:
1- parallele addition parallèle von jeder elemente jede blocke:
1. elt bloc0 + 1.elt bloc1+...+ 1. elt blocn = X
2- danach das ergebnis durch anzahl des block NB teilen,  NB=manzahl des blocke
X/ NB = R
3- das ergebnis R ist dann in der array res gespeichert

die schritte 1 bis 3 sollte für jede elemente eine block wiederholen werden 

Mein problem ist folgende:
ich weiss nicht wie ich das alles richtig in CUDA implementieren könnte, 
In C weiss ich das tab[i] = elemt i des array tab
in CUDA komme ich damit nicht so klar mit verwendung von : blockDim.x, blockIdx.x, threadIdx.x; [IMG]http://www.developpez.net/forums/images/smilies/icon_sad.gif[/IMG]
*/


__global__ void MoyenneTab( float* v1, float* res)
{
	unsigned int i = blockDim.x * blockIdx.x + threadIdx.x;
	int sum = 0 ;
	
	if (i < 39063) sum+= v1[i];
	
	sum/= 39063;
	res[i]  = sum ;
}




int main()
{
    
	unsigned int N = 10000000 // arrays grosse
	unsigned int i; 

	
	float *h_v1 = (float*) malloc( N*sizeof(float) ); 
	float *h_res = (float*) malloc( N*sizeof(float) );  
	
	
	// initializierung
	i = 0;
	while(i < N)
	{
		h_v1[i] = i;
		h_res[i]=0;
		
		i++;	
	}
	
	
	float *d_v1;
	float *d_res;

	cudaMalloc( (void**) &d_v1, N*sizeof(float) );	
	cudaMalloc( (void**) &d_res, N*sizeof(float) );	
	
	cudaMemcpy(d_v1, h_v1, N*sizeof(float), cudaMemcpyHostToDevice);

/* hier wähle ich 256 threads per bloc
    39063 = 10000000 / 256  ===> blocks anzahl */
	
	MoyenneTab<<<39063, 256>>>(d_v1, d_res);
	
    cudaThreadSynchronize();
	
    cudaMemcpy(h_res, d_res, N*sizeof(float), cudaMemcpyDeviceToHost);
		
    cudaFree(d_v1);
    cudaFree(d_res);
    
}

Ich bitte echt um Hilfe, denn ich brauch die Kode für einer Projekt
hoffenlich meldet sich jemand
danke
mfg
army