[CUDA] Unterschied zwischen Rechenfunktionen?

Larkis

__global__ void kernel( unsigned char *ptr, int ticks ) {
	int x = threadIdx.x + blockIdx.x * blockDim.x;
	int y = threadIdx.y + blockIdx.y * blockDim.y;
	float x1 = threadIdx.x + blockIdx.x * blockDim.x;
	float y1 = threadIdx.y + blockIdx.y * blockDim.y;
	float time = ticks;
	int offset = x + y * blockDim.x * gridDim.x;

	float fx = x - DIM/2;
	float fy = y - DIM/2;
	float d = sqrtf(fx * fx + fy * fy);

	//unsigned char grey = (unsigned char) (128.0f + 127.0f * cos(d/10.0f - ticks/7.0f) / (d/10.0f + 1.0f));
	unsigned char grey = (unsigned char) (255 - ((150 - time / 10) / 150 * (sin(fx / 160) * cos(fy / 350)) * 255 / 2));
	ptr[offset*4 + 0] = 0;
	ptr[offset*4 + 1] = 0;
	ptr[offset*4 + 2] = grey;
	ptr[offset*4 + 3] = 255;
}

Das ist Teil meiner aktuellen CUDA Funktion. Diese stellen eine Animation dabei, wobei die übergebene Variable ticks den Zeitindex darstellt.

Mit der ausgeklammerten Funktion grey habe ich eine Animation, mit der aktiven Funktion grey aber nur ein Standbild.

Ich muss uzugeben das ich die Original-Rechnung mit diesen zahl.0f nicht so ganz verstehe und vermute da liegt der Schlüssel. Aber auch wenn ich meine Funktion bei den Zahlen mit diesem .0f erweitere ist da nur ein statisches Bild.

Jemand eine Idee?

Was kann man eigentlich so tolles mit diesem CUDA machen?

Larkis

Als Anfänger, parallele Berechnungen komplexer Formeln über die Grafikkarte. In meinem Fall, ein Bild generieren mit 500*500 Pixeln. Mit normaler Programmiersprache muss ich jeden Pixel nacheinander berechnen mit CUDA berechne ich über die Grafikkarte alle gleichzeitig.

Mathew

Barracuda ^^ schrieb:

Was kann man eigentlich so tolles mit diesem CUDA machen?

Nichts neues, es ist nur zum Beschleunigen bestehender C++ Programme gedacht.

Swordfish

Mathew schrieb:

[...] zum Beschleunigen bestehender C++ Programme gedacht.

wtf?

Mathew schrieb:

Barracuda ^^ schrieb:

Was kann man eigentlich so tolles mit diesem CUDA machen?

Nichts neues, es ist nur zum Beschleunigen bestehender C++ Programme gedacht.

ooops!!!
ein tollpatschiger tritt ins wespennest?

Larkis

Hier nochmal der komplette Quellcode. Ich hab zwar eine Animation, es sieht aber dennoch nicht so aus wie es aussehen sollte, irgentwie scheint er die Formel falsch zu interpretieren...

#include "../common/cpu_bitmap.h"
#include "../common/cpu_anim.h"
#include "../common/book.h"
#include "math.h"
#include "stdio.h"
const int DIM = 500;

struct DataBlock {
	unsigned char *dev_bitmap;
	CPUAnimBitmap *bitmap;
};

__global__ void kernel( unsigned char *ptr, int ticks ) {
	int x = threadIdx.x + blockIdx.x * blockDim.x;
	int y = threadIdx.y + blockIdx.y * blockDim.y;
	float time = ticks;
	int offset = x + y * blockDim.x * gridDim.x;

	float fx = x - DIM/2;
	float fy = y - DIM/2;
	float sinus = (fx - DIM/2) / 160.0f;
	float cosinus = (fy - DIM/2) / 350.0f;
	//unsigned char grey = (unsigned char) (128.0f + 127.0f * cos(d/10.0f - ticks/7.0f) / (d/10.0f + 1.0f));
	unsigned char grey = (unsigned char) (255.0f - (150.0f - ticks / 10.0f) / 150.0f * (sin(sinus) * cos(cosinus) * 255.0f / 2.0f));
	ptr[offset*4 + 0] = 0;
	ptr[offset*4 + 1] = 0;
	ptr[offset*4 + 2] = grey;
	ptr[offset*4 + 3] = 255;
}

void generate_frame( DataBlock *d, int ticks) {
	dim3 blocks(DIM/16,DIM/16);
	dim3 threads(16,16);
	kernel<<<blocks,threads>>>( d->dev_bitmap, ticks );

	cudaMemcpy( d->bitmap->get_ptr(),
				d->dev_bitmap,
				d->bitmap->image_size(),
				cudaMemcpyDeviceToHost);
}

void cleanup( DataBlock *d) {
	cudaFree( d->dev_bitmap );
}

int main( void ) {
	DataBlock data;
	CPUAnimBitmap bitmap( DIM, DIM, &data );
	data.bitmap = &bitmap;
	cudaMalloc( (void**) &data.dev_bitmap, bitmap.image_size() );
	bitmap.anim_and_exit( (void (*) (void*,int))generate_frame, (void (*)(void*))cleanup );
}

rapso

Swordfish schrieb:

Mathew schrieb:

[...] zum Beschleunigen bestehender C++ Programme gedacht.

wtf?

lol, du scheinst, wie die meisten, es nicht zu wissen :D, doch dem ist so, hatte ich auch da schon geschrieben.

nicht c++ zu koennen und mit CUDA anzufangen macht wenig sinn. mehr wollen wir Larkis nicht begreiflich machen, zumindestens ich.

meine CUDA programme laufen auch alle auf cpu-only und ich entwickel sie erst auf CPU only und portiere dann schritt fuer schritt auf CUDA bzw OpenCL. Ich denke es ist echt selten, dass jemand direkt in CUDA anfaeng zu implementieren, es macht nicht soviel sinn, da man algorithmen usw. ja erst fehlerfrei laufen haben will, bevor man anfaengt zu optimieren und da ist CPU code, gerade mit edit&continue und all den netten VS featuren weit besser geeignet als CUDA. CUDA/OpenCL kommt am ende dran, wenn alles richtig funktioniert und auch dann so, dass ich per compile flag zwischen CPU only und GPU wechseln kann, denn bugs koennen immer noch auftauchen.

mein geheimtipp ist da das IntelSDK, die haben opencl wirklich sehr gut in visual studio integriert (Eclipse wohl auch, hab ich aber noch nie ausprobiert). Mit OpenCL kann man dann fast arbeiten wie mit c++@CPU.
Die NVidia tools sind vorher die besten gewesen, aber sie sind eigentlich voll auf optimieren ausgelegt, einfach nur algorithmen debuggen ist da nicht so einfach, z.B. braucht man eine zweite GPU, weil eine von Windows unbedingt fuer den desktop gebraucht wird. also entweder remote GPU debugging, oder sowas wie GTX590 oder GTX690 verbauen.

Larkis

rapso schrieb:

nicht c++ zu koennen und mit CUDA anzufangen macht wenig sinn. mehr wollen wir Larkis nicht begreiflich machen, zumindestens ich.

Finde ich auch sehr nett von dir. Nur wie ich glaub ich im anderen Thread schon gesagt habe, beides getrennt zu lernen ist ein Luxus den ich mir zeitlich nicht leisten kann.

In 2 Wochen muss muss ich obigen Quellcode nicht nur Fehlerfrei zum laufen kriegen sondern das ganze möglichst auch noch in 3D darstellen.

Daher währe ich über Hilfe in der Hinsicht echt dankbar.