NVIDIA rilascia la versione 2.2 del toolkit CUDA

NVIDIA rilascia la versione 2.2 del toolkit CUDA

La società californiana continua a spingere l'acceleratore sulla propria piattaforma GPGPU, introducendo la versione 2.2 del toolkit e SDK di CUDA

di pubblicata il , alle 14:32 nel canale Schede Video
NVIDIACUDA
 

Continua il supporto per il GPGPU, elemento su cui NVIDIA punta molto per lo sviluppo prossimo e futuro delle proprie schede grafiche. La società americana, infatti, da un po' di tempo a questa parte spinge proprio sui cosiddetti valori aggiunti delle schede grafiche: la GPU viene identificata come mezzo utile per l'esecuzione dei videogiochi, e NVIDIA intende andare oltre questo legame fin troppo forte.

Viene così annunciato il rilascio della versione 2.2 del Toolkit e dell'SDK di CUDA, l'architettura GPGPU distribuita e sviluppata da NVIDIA. La nuova versione include importanti miglioramenti, uno su tutti il supporto a Windows 7, il futuro sistema operativo di Microsoft. Tutti gli interessati possono trovare il software a questo indirizzo.

Questo invece un elenco dei principali miglioramenti apportati con la nuova versione:

  • Visual Profiler for the GPU
    The most common step in tuning application performance is profiling the application and then modifying the code. The CUDA Visual Profiler is a graphical tool that enables the profiling of C applications running on the GPU. This latest release of the CUDA Visual Profiler includes metrics for memory transactions, giving developers visibility into one of the most important areas they can tune to get better performance.
  • mproved OpenGL Interop
    Delivers improved performance for Medical Imaging and other OpenGL applications running on Quadro GPUs when computing with CUDA and rendering OpenGL graphics functions are performed on different GPUs.
  • Texture from Pitch Linear Memory
    Delivers up to 2x bandwidth savings for video processing applications.
  • Zero-copy
    Enables streaming media, video transcoding, image processing and signal processing applications to realize significant performance improvements by allowing CUDA functions to read and write directly from pinned system memory. This reduces the frequency and amount of data copied back and forth between GPU and CPU memory. Supported on MCP7x and GT200 and later GPUs.
  • Pinned Shared Sysmem
    Enables applications that use multiple GPUs to achieve better performance and use less total system memory by allowing multiple GPUs to access the same data in system memory. Typical multi-GPU systems include Tesla servers, Tesla Personal Supercomputers, workstations using QuadroPlex deskside units and consumer systems with multiple GPUs.
  • Asynchronous memcopy on Vista
    Allows applications to realize significant performance improvements by copying memory asynchronously. This feature was already available on other supported platforms but is now available on Vista.
  • Hardware Debugger for the GPU
    Developers can now use a hardware level debugger on CUDA-enabled GPUs that offers the simplicity of the popular open-source GDB debugger yet enables a developer to easily debug a program that is running 1000s of threads on the GPU. This CUDA GDB debugger for Linux has all the features required to debug directly on the GPU, including the ability to set breakpoints, watch variables, inspect state, etc.
  • Exclusive Device Mode
    This system configuration option allows an application to get exclusive use of a GPU, guaranteeing that 100% of the processing power and memory of the GPU will be dedicated to that application. Multiple applications can still be run concurrently on the system, but only one application can make use of each GPU at a time. This configuration is particularly useful on Tesla cluster systems where large applications may require dedicated use of one or more GPUs on each node of a Linux cluster.

Resta aggiornato sulle ultime offerte

Ricevi comodamente via email le segnalazioni della redazione di Hardware Upgrade sui prodotti tecnologici in offerta più interessanti per te

Quando invii il modulo, controlla la tua inbox per confermare l'iscrizione.
Leggi la Privacy Policy per maggiori informazioni sulla gestione dei dati personali

7 Commenti
Gli autori dei commenti, e non la redazione, sono responsabili dei contenuti da loro inseriti - info
gpat11 Maggio 2009, 14:37 #1
Figo, ora lo provo con la G105m del mio nuovo notebook.
cervus9211 Maggio 2009, 14:57 #2
Originariamente inviato da: gpat
Figo, ora lo provo con la G105m del mio nuovo notebook.


Lo provi per fare cosa?
Spyto11 Maggio 2009, 15:09 #3
Originariamente inviato da: cervus92
Lo provi per fare cosa?

Be sono librerie per C, e sono strutturate sopratutto per fare calcoli puri...
mjordan11 Maggio 2009, 15:45 #4
Originariamente inviato da: Spyto
Be sono librerie per C, e sono strutturate sopratutto per fare calcoli puri...


[code]
#include <cuda.h>
#include <stdio.h>

// Prototypes
__global__ void helloWorld(char*);

// Host function
int
main(int argc, char** argv)
{
int i;

// desired output
char str[] = "Hello World!";

// mangle contents of output
// the null character is left intact for simplicity
for(i = 0; i < 12; i++)
str[i] -= i;

// allocate memory on the device
char *d_str;
size_t size = sizeof(str);
cudaMalloc((void**)&d_str, size);

// copy the string to the device
cudaMemcpy(d_str, str, size, cudaMemcpyHostToDevice);

// set the grid and block sizes
dim3 dimGrid(2); // one block per word
dim3 dimBlock(6); // one thread per character

// invoke the kernel
helloWorld<<< dimGrid, dimBlock >>>(d_str);

// retrieve the results from the device
cudaMemcpy(str, d_str, size, cudaMemcpyDeviceToHost);

// free up the allocated memory on the device
cudaFree(d_str);

// everyone's favorite part
printf("%s\n", str);

return 0;
}

// Device kernel
__global__ void
helloWorld(char* str)
{
// determine where in the thread grid we are
int idx = blockIdx.x * blockDim.x + threadIdx.x;

// unmangle output
str[idx] += idx;
}
[/code]

Hai provato a fare qualcosa con OpenCL già?
EDIT: Segnalo che CUDA 2.2 viene installato di default con i 185.85 WHQL che tra l'altro sono disponibili anche per notebook (ovviamente non parlo dell'SDK e del toolkit)
Mi piace molto il thread model basato su "grid" e il concetto di kernels, in CUDA: veramente elegante.
[code]
// Kernel definition
__global__ void MatAdd(float A[N][N], float B[N][N], float C[N][N])
{
int i = blockIdx.x * blockDim.x + threadIdx.x;
int j = blockIdx.y * blockDim.y + threadIdx.y;
if (i < N && j < N)
C[i][j] = A[i][j] + B[i][j];
}

int main()
{
// Kernel invocation
dim3 dimBlock(16, 16);
dim3 dimGrid((N + dimBlock.x &#8211; 1) / dimBlock.x, (N + dimBlock.y &#8211; 1) / dimBlock.y);
MatAdd<<<dimGrid, dimBlock>>>(A, B, C);
}
[/code]

256 threads power.
ledlama11 Maggio 2009, 16:02 #5
Originariamente inviato da: cervus92
Lo provi per fare cosa?



Originariamente inviato da: Spyto
Be sono librerie per C, e sono strutturate sopratutto per fare calcoli puri...


cosa gli rispondi a fare!!!! voleva prenderti in giro! troll maledetti

cmq sta andando avanti a razzo nvidia .....
cervus9211 Maggio 2009, 16:33 #6
Originariamente inviato da: ledlama
cosa gli rispondi a fare!!!! voleva prenderti in giro! troll maledetti

cmq sta andando avanti a razzo nvidia .....


così a razzo che tra poco scoprono un nuovo satellite della terra...
ledlama11 Maggio 2009, 17:49 #7
Originariamente inviato da: cervus92
così a razzo che tra poco scoprono un nuovo satellite della terra...


-_-'

Devi effettuare il login per poter commentare
Se non sei ancora registrato, puoi farlo attraverso questo form.
Se sei già registrato e loggato nel sito, puoi inserire il tuo commento.
Si tenga presente quanto letto nel regolamento, nel rispetto del "quieto vivere".

La discussione è consultabile anche qui, sul forum.
 
^