Newsgroup: it.comp.hardware.video-3d
Titolo: [OT da ridere] Che utente sei?

http://kimag.es/share/22415209.png
AHHAHAHHAHHA
:-P
-- 
SimBus82.net coming soon - 
http://www.simbus82.net
Blog allenamento - 
http://simbus82-workout.blogspot.com/
 


ROFL.
Anche se c'� poco da ridere. E' cos� cazzo.

BS82 wrote:
Vero forse per gli utenti dei giochini.
Nel resto delle applicazioni di questo universo, a partire dal semplice
supporto Linux per arrivare al calcolo parallelo, nVidia �
oggettivamente avanti.
Gente che acquista il portatile con l'idea di cassare Win acquista
nVidia, sui PC destinati alla grafica 3D in facolt� (e anche nei 3 studi
che conosco) si montano Quadro, ed � tutta gente che davvero non ha
tempo di andare a fare l'utonto a sostenere una marca di schede video.
Detto questo, un AMD-user � un "tifoso" oppure � uno che ce l'ha nel
case? Nel secondo caso ci rientrerei avendone 2 (+1 di riserva) :)
-- 
Ing. Danilo Pianini
"DanySK"
MSN: danysk_AT_alientech_DOT_it
Skype: 
dany.sk

 oggettivamente avanti.
e uno :D


 :-P
LOL, bellissima e abbastanza realistica :D

 
Beh, in effetti con CUDA Nvidia � oggettivamente avanti rispetto al Brook+ 
di ATI (anche se c'� da dire che con le ultime release ATI si � riportata 
abbastanza sotto, ma ovviamente la gran parte degli utenti ormai usa la 
soluzione Nvidia).
Ora c'� lo standard OpenCL, per cui entrambi sono partiti alla pari e sar� 
interessante vedere chi sar� il migliore.
Al momento sto usando una 5770 per un progetto di datamining con OpenCL e 
devo dire che purtroppo i driver attuali (i beta4) sono ancora un po' 
immaturi (ma credo che lo stesso problema lo abbia anche Nvidia).

 Ora c'� lo standard OpenCL, per cui entrambi sono partiti alla pari e sar� 
E qui ti sbagli: se guardi, OpenCL � esattamente uguale a CUDA driver.
Cambiano solo i nomi di costanti e comandi.
Purtroppo AMD non ha spinto a sufficienza la sua soluzione, nonostante
Brook+ fosse un linguaggio decisamente pi� abbordabile di C+CUDA.


 Cambiano solo i nomi di costanti e comandi.
Non conosco CUDA...quindi dici che le API sono molto simili?

 Non conosco CUDA...quindi dici che le API sono molto simili?
Valuta da solo, ti posto due code examples presi dalla OpenCL
programming guide di nVidia:
const unsigned int cnBlockSize = 512;
const unsigned int cnBlocks = 3;
const unsigned int cnDimension = cnBlocks * cnBlockSize;
/*=====CUDA=====*/
CUdevice hDevice;
CUcontext hContext;
CUmodule hModule;
CUfunction hFunction;
// create CUDA device & context
cuInit(0);
cuDeviceGet(&hContext, 0); // pick first device
cuCtxCreate(&hContext, 0, hDevice));
cuModuleLoad(&hModule, “vectorAdd.cubin”);
cuModuleGetFunction(&hFunction, hModule, "vectorAdd");
// allocate host vectors
float * pA = new float[cnDimension];
float * pB = new float[cnDimension];
float * pC = new float[cnDimension];
// initialize host memory
randomInit(pA, cnDimension);
randomInit(pB, cnDimension);
// allocate memory on the device
CUdeviceptr pDeviceMemA, pDeviceMemB, pDeviceMemC;
cuMemAlloc(&pDeviceMemA, cnDimension * sizeof(float));
cuMemAlloc(&pDeviceMemB, cnDimension * sizeof(float));
cuMemAlloc(&pDeviceMemC, cnDimension * sizeof(float));
// copy host vectors to device
cuMemcpyHtoD(pDeviceMemA, pA, cnDimension * sizeof(float));
cuMemcpyHtoD(pDeviceMemB, pB, cnDimension * sizeof(float));
// setup parameter values
cuFuncSetBlockShape(cuFunction, cnBlockSize, 1, 1);
cuParamSeti(cuFunction, 0, pDeviceMemA);
cuParamSeti(cuFunction, 4, pDeviceMemB);
cuParamSeti(cuFunction, 8, pDeviceMemC);
cuParamSetSize(cuFunction, 12);
// execute kernel
cuLaunchGrid(cuFunction, cnBlocks, 1);
// copy the result from device back to host
cuMemcpyDtoH((void *) pC, pDeviceMemC, cnDimension * sizeof(float));
delete[] pA;
delete[] pB;
delete[] pC;
cuMemFree(pDeviceMemA);
cuMemFree(pDeviceMemB);
cuMemFree(pDeviceMemC);
/*=====OpenCL=====*/
// create OpenCL device & context
cl_context hContext;
hContext = clCreateContextFromType(0, CL_DEVICE_TYPE_GPU,
0, 0, 0);
// query all devices available to the context
size_t nContextDescriptorSize;
clGetContextInfo(hContext, CL_CONTEXT_DEVICES, 0, 0,
&nContextDescriptorSize);
cl_device_id * aDevices = malloc(nContextDescriptorSize);
clGetContextInfo(hContext, CL_CONTEXT_DEVICES,
nContextDescriptorSize, aDevices, 0);
// create a command queue for first device the context reported
cl_command_queue hCmdQueue;
hCmdQueue = clCreateCommandQueue(hContext, aDevices[0], 0, 0);
// create & compile program
cl_program hProgram;
hProgram = clCreateProgramWithSource(hContext, 1,
sProgramSource, 0, 0);
clBuildProgram(hProgram, 0, 0, 0, 0, 0);
// create kernel
cl_kernel hKernel;
hKernel = clCreateKernel(hProgram, “vectorAdd”, 0);
// allocate host vectors
float * pA = new float[cnDimension];
float * pB = new float[cnDimension];
float * pC = new float[cnDimension];
// initialize host memory
randomInit(pA, cnDimension);
randomInit(pB, cnDimension);
// allocate device memory
cl_mem hDeviceMemA, hDeviceMemB, hDeviceMemC;
hDeviceMemA = clCreateBuffer(hContext,
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
cnDimension * sizeof(cl_float),
pA,
0);
hDeviceMemB = clCreateBuffer(hContext,
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
cnDimension * sizeof(cl_float),
pA,
0);
hDeviceMemC = clCreateBuffer(hContext, CL_MEM_WRITE_ONLY,
cnDimension * sizeof(cl_float), 0, 0);
// setup parameter values
clSetKernelArg(hKernel, 0, sizeof(cl_mem), (void *)&hDeviceMemA);
clSetKernelArg(hKernel, 1, sizeof(cl_mem), (void *)&hDeviceMemB);
clSetKernelArg(hKernel, 2, sizeof(cl_mem), (void *)&hDeviceMemC);
// execute kernel
clEnqueueNDRangeKernel(hCmdQueue, hKernel, 1, 0, &cnDimension, 0, 0, 0, 0);
// copy results from device back to host
clEnqueueReadBuffer(hContext, hDeviceMemC, CL_TRUE, 0,
cnDimension * sizeof(cl_float),
pC, 0, 0, 0);
delete[] pA;
delete[] pB;
delete[] pC;
clReleaseMemObj(hDeviceMemA);
clReleaseMemObj(hDeviceMemB);
clReleaseMemObj(hDeviceMemC);
La principale differenza alla fin fine è che le applicazione CUDA son
compilate offline, le OpenCL dinamicamente (per ragioni di portabilità
credo, dato che non sono forniti strumenti di reflection). A livello di
linguaggio sono estremamente analoghi.
Per approfondimenti, questo documento è ben fatto:
http://developer.download.nvidia.com/OpenCL/NVIDIA_OpenCL_JumpStart_Guide.pdf


 .pdf 
Azz � vero, sono molto simili...