[CUDA] Shared Memory

[Valhalla]

Salve,

sarei curioso di sapere come è organizzata e come si comporta la shared memory all'interno dell'architettura cuda. In particolare si parla di una shared memory per ciascun MP (nel mio caso, ho una GF210 2 MP quindi 2 SM da 16 KB ciascuna). Ciascun blocco ha una shared memory, al cui interno thread appartenenti allo stesso blocco possono condividere dati. Ciò vuol dire che se io, all'interno di un MP ho una shared memory da 16KB, e avendo 8 blocchi, ciascun blocco vede 2KB?
Sostanzialmente il mio problema riguarda la ripartizione di un'immagine, e io vorrei fare in modo che l'elaborazione di ciascuna parte sia effettuata a partire dalla shared memory e non dalla memoria globale a disposizione (più lenta). Non sapendo però in che misura effettuare tale ripartizione, ho paura di non apportare nessun miglioramento!! Se c'è qualche anima pia che mi possa chiarire le cose gliene sarei grato :D

P.S. Allego le specifiche della mia scheda video

CUDA Device Query (Driver API) statically linked version
There is 1 device supporting CUDA

Device 0: "GeForce 210"
CUDA Driver Version: 3.0
CUDA Capability Major revision number: 1
CUDA Capability Minor revision number: 2
Total amount of global memory: 536870912 bytes
Number of multiprocessors: 2
Number of cores: 16
Total amount of constant memory: 65536 bytes
Total amount of shared memory per block: 16384 bytes
Total number of registers available per block: 16384
Warp size: 32
Maximum number of threads per block: 512
Maximum sizes of each dimension of a block: 512 x 512 x 64
Maximum sizes of each dimension of a grid: 65535 x 65535 x 1
Maximum memory pitch: 262144 bytes
Texture alignment: 256 bytes
Clock rate: 1.40 GHz
Concurrent copy and execution: Yes
Run time limit on kernels: No
Integrated: No
Support host page-locked memory mapping: Yes
Compute mode: Default (multiple host threads can use this device simultaneously)

[marco.r]

Salve,

sarei curioso di sapere come è organizzata e come si comporta la shared memory all'interno dell'architettura cuda. In particolare si parla di una shared memory per ciascun MP (nel mio caso, ho una GF210 2 MP quindi 2 SM da 16 KB ciascuna). Ciascun blocco ha una shared memory, al cui interno thread appartenenti allo stesso blocco possono condividere dati. Ciò vuol dire che se io, all'interno di un MP ho una shared memory da 16KB, e avendo 8 blocchi, ciascun blocco vede 2KB?

Se ogni blocco ha una shared memory da 16KB, ogni blocco vede 16 KB :D. La shared memory e' specifica di un singolo processore e quindi questo la vede tutta (ed e' il motivo perche' thread di altri blocchi non la vedono).

[Valhalla]

ma allora se io ho 500 blocchi ciascuno di essi ha 16KB di memoria shared a disposizione? mi sembra un pò strano :what:

[Kenger]

Se tu hai 500 blocchi tutti vedono gli stessi 16Kb di memoria, non è che ognuno ha i suoi 16Kb.

[marco.r]

ma allora se io ho 500 blocchi ciascuno di essi ha 16KB di memoria shared a disposizione? mi sembra un pò strano :what:
E' scritto nelle specifiche che hai riportato, basta leggerle:


Total amount of shared memory per block: 16384 bytes

Tieni presente che i tuoi 500 blocchi non gireranno contemporaneamente, ma tanti alla volta quanti sono gli stream processors (che sono le unita' fisiche che effettivamente hanno 16KB di memoria). Nel tuo caso questi dovrebbero essere 16 :

Number of cores: 16


Riassumendo:
- la tua esecuzione viene suddivisa in blocchi (nel tuo caso 500)
- ogni blocco viene eseguito da uno stream processor differente, per quanto possibile in parallelo "a colpi" di tanti blocchi quanti sono i processori (nel tuo caso 16)
- ognuno di questi processori ha una piccola memoria cache di una certa dimensione (nel tuo caso 16KB), che i singoli thread all'interno del blocco possono utilizzare per condividere i risultati delle loro operazioni
- Idealmente tutte le operazioni di scrittura del blocco dovrebbero avvenire nella shared memory e non nella memoria comune.

[Tommo]

E per apportare miglioramenti: più riesci ad usarne e meglio è!

Dato che è sempre più veloce della memoria globale, è sempre meglio sostituire l'una con l'altra quando possibile.
Il problema è che spesso è molto difficile trovare un modo per "piegare" gli algoritmi ad usarla, perchè è visibile solo ad "alcuni" threads in esecuzione...

nel caso di un'immagine però dovrebbe essere possibile... ma fai attenzione ai bordi del blocco :D

[Valhalla]

Vi ringrazio per le spiegazioni.

In realtà quello che ho capito io, è che ciascun blocco vede la sua shared memory, questo perchè i thread appartenenti ad un blocco possono condividere dati per mezzo della shared memory. Viene da se dunque che ogni blocco ha la sua shared memory, e questo non lo intuisco io, ma l'ho proprio letto all'interno della programming guide:

Each thread block has a shared memory visible to all threads of the block and with the same lifetime as the block. Finally, all threads have access to the same global memory. (Pag. 18/145 Programming Guide 2.3)

Ipotizziamo che io abbia un solo multiprocessore, quindi con 8 core a disposizione. Ora, io creo 10 blocchi, la shared memory è, per ciascuno di loro, di 16 KB? O la shared memory complessiva del MP a disposizione è di 16KB e quindi questi 10 blocchi hanno a disposizione rispettivamente 1,6KB di memoria ciascuno? Inoltre si parla di blocco collegato al MP e non al core, per cui è possibile che 2 thread di uno stesso blocco possano girare su due cose differenti (questo perchè, ad esempio, 6 core possono essere occupati da un unico blocco e i restanti 2 core altri 2 blocchi, mentre i restanti sono in waiting)?

Io ho un'immagine, che per comodità d'esempio, è di dimensioni fisse, con una risoluzione multipla di 32 (per facilitare i conti), tipo 640x480. Questa immagine io la voglio spezzare in 32 rettangoli e ciascun rettangolo darlo in pasto ad un thread al fine di poter effettuare dei calcoli. Ora, il mio voler spezzare in 32 la mia immagine è sparato a caso, in quanto se io sapessi come è organizzata la shared memory io potrei spezzare l'immagine secondo la massima capacità della stessa shared memory (per ciascun blocco). Insomma vorrei fare in modo che ciascun blocco di thread abbia una porzione di immagine contenuta all'interno della shared memory in maniera da sfruttarla interamente.

Grazie a tutti anticipatamente :)

[Valhalla]

Allego un'immagine per spiegarmi meglio.

http://img7.imageshack.us/img7/4263/immaginekpt.th.jpg (http://img7.imageshack.us/i/immaginekpt.jpg/)

Granularità:

Con A ho indicato il singolo pixel;
Con B un gruppo di pixel, da dare in pasto ad un thread, che analizzerà i pixel appartenenti a quel gruppo a partire dal pixel centrare per poi spostarsi nei pixel adiacenti secondo 8 direzioni (su, giù, sinistra, destra, diagonali)
Con C indico i frame e cioè ciò che poi darò in pasto ad ogni singolo blocco.

[Tommo]

Stai facendo un sacco di discorsi inutili temo, perchè come è perfettamente spiegato, un blocco ha 16K di memoria.
Sempre.
Comunque.
Qualunque numero di blocchi.
:asd:

La memoria per thread è data da 16384/threads_nel_blocco.

Questo si spiega perchè internamente, il Thread Hardware vero e proprio non è quello che ti presenta CUDA, ma quello che gira sul Multiprocessore.
quindi un Hardware Thread ha a disposizione istruzioni 32-wide (in realtà 16+16), cioè che operano su 32 elementi alla volta, che girano sugli 8 stream processors.
Tramite quelle istruzioni emula i 256 thread del blocco.

Però l'unità di esecuzione, quella fisicamente dotata di memoria cache, è il multiprocessore, cioè l'intero blocco.
Per cui un blocco di thread operante su un multiprocessore ha per forza di cose a disposizione tutta la memoria del dispositivo... non puoi eseguire due blocchi contemporaneamente sullo stesso!
E lo stesso ragionamento vale anche per i registri.

[Valhalla]

Stai facendo un sacco di discorsi inutili temo, perchè come è perfettamente spiegato, un blocco ha 16K di memoria.
Sempre.
Comunque.
Qualunque numero di blocchi.
:asd:

e fin qui questo è chiaro :)

Tramite quelle istruzioni emula i 256 thread del blocco.

256? 512 vorrai dire..

Però l'unità di esecuzione, quella fisicamente dotata di memoria cache, è il multiprocessore, cioè l'intero blocco.
Per cui un blocco di thread operante su un multiprocessore ha per forza di cose a disposizione tutta la memoria del dispositivo... non puoi eseguire due blocchi contemporaneamente sullo stesso!
E lo stesso ragionamento vale anche per i registri.

quindi in sostanza ritorniamo a quanto detto prima che 500 blocchi hanno 500 diverse shared memory da 16K.