GPGPU

General-purpose computing on graphics processing units (Computació de propòsit general sobre unitats de processament gràfic. GPGPU, també conegut com a GPGP o GP²) és la tècnica de fer servir GPUs per a fer computació en aplicacions tradicionalment tractades per la CPU. L'addició de fases programables i la precisió més gran en els pipelines de renderització ha permès als desenvolupadors de software fer servir GPUs per a aplicacions no relacionades amb els gràfics. Mitjançant l'explotació de l'arquitectura molt més paral·lela de les GPUs (a l'abril de 2008: 128 nuclis en comptes dels 4 nuclis de les CPUs), expressant els problemes com a dades paral·leles, molts problemes de computació poden ser accelerats considerablement.

La funcionalitat de les GPU ha estat, tradicionalment, molt limitada. De fet, durant molts anys les GPUs van ser utilitzades per accelerar certes parts de les tasques gràfiques. Es necessitaven alguns canvis abans que les GPGPU fossin viables.

Els vertex shaders i fragment shaders programables van ser afegits a les tasques gràfiques per a permetre als programadors de jocs la generació d'efectes encara més realistes. Els vertex shaders permeten al programador alterar atributs per vèrtex, com ara la posició, el color, les coordenades de les textures, i el vector normal. Els fragments shaders es fan servir para calcular el color d'un fragment o de cada píxel. Els fragment shaders programables permeten al programador la substitució, per exemple, d'un model d'il·luminació diferent del que la tarjeta gràfica porta per defecte, habitualment sombrejat Gouraud. Els shaders han permès als programadors de gràfics crear efectes de lent, desplaçament de mapa, i profunditat del terreny.

La programabilitat dels pipelines ha evolucionat d'acord amb l'especficació de Microsoft DirectX, quan DirectX 8 va presentar Shader Model 1.1, DirectX 8.1 Pixel Shader Models 1.2, 1.3 i 1.4, i DirectX 9 defninit Shader Model 2.x i 3.0. Cada shader model va incrementar la flexibilitat i la capacitat del model de programació. L'especificació DirectX 10 introdueix el Shader Model 4.0, que unifica l'especificació de programació per a vèrtexs, geometria i processament de fragments, permetent una adaptació millor del maquinari shader unificat.

Les GPUs han estat dissenyades específicament per a gràfics i per això són molt restrictives quant a operacions i programació. A causa de la seva naturalsea, les GPUs només són efectives abordant problemes que poden ser resolts fent servir processament de strems i el maquinari només es pot fer servir de certes formes.

Les GPUs només poden processar vèrtexs i fragments independents, però poden processar molts d'aquests en paral·lel. Això és especialment efectiu quan el programador vol processar molts vèrtexs o fragments de la mateixa forma. En aquest sentit, les GPUs són processadors de streams - processadors que poden operar en paral·lel mitjançant l'execució del mateix kernel a molts registres d'un stream al mateix temps.

Un stream és simplement un conjunt de registres que requereixen càlculs similars. Els streams ofereixen paral·lelisme de dades. Els nuclis (kernels) són les funcions que són aplicades a cada element de l'stream. A les GPUs, els vèrtexs i els fragments són els elements del stream i els shaders de vèrtex i de fragments són els kernels a executar sobre ells. Ja que les GPUs processen elements independentment, no es poden tenir dades compartides en l'espai o el temps. Per a cada element només podem llegir-lo de l'entrada, fer-li operacions, i escriure'l cap a la sortida. És permissible tenir múltiples entrades i sortides, però mai un tros de memòria que pot ser reutilitzat per diverses GPUs al mateix temps o per qualsevol GPU en dos moments diferents. Plantilla:Vague.

La intensitat aritmètica és definida com el nombre d'operacions realitzades per paraula de memòria comunicada entre la unitat de procés i la memòria. És favorable per a les aplicacions GPGPU tenir una intensitat aritmètica alta o en cas contrari, la latència d'accés a memòria limitarà la velocitat de càlcul.

Les aplicacions ideals GPGPU tenen grans conjunts de dades, alt paral·lelisme i mínima dependència entre elements de dades.

Una GPU disposa de diversos recursos computacionals:

• Processadors programables - Els conductes de vèrtex, primitives i fragments permeten al programador executar en els nuclis els corrents de dades
• Rasteritzadors - Creen fragments i interpolen constants per cada vèrtex com ara coordenades de textures i color
• Unitat de textura - Interfície de memòria de només lectura
• Framebuffer - Interfície de memòria de només lectura

De fet, el programador pot substituir una textura de només escriptura per a sortida en comptes del framebuffer. Això s'aconsegueix mitjançant Render-To-Texture (RTT), Render-To-Backbuffer-Copy-To-Texture (RTBCTT), o el més recent stream-out.

La forma més comuna en què un stream arriba a una GPGPU és una graella 2D, ja que això s'ajusta de manera natural amb el model de rendering construït a les GPUs. Molts càlculs s'ubiquen de manera natural en graelles: àlgebra de matrius, processament d'imatges, simulacions basades en física, i altres similars.

Ja que les textures es fan servir com a memòria, les lectures de textures es fan servir com a lectures de memòria. Algunes operacions es poden fer automàticament fer servir les GPUs a causa d'això.

Els nuclis es poden interpretar com el cos dels bucles. Per exemple, si el programador estigués fent operacions a una graella a la CPU, podria tenir codi similar al següent:

/* Pseudocodi */

x = 1e8
y = 1e8

fes array de x per y

for each "x" { // Itera aquest bloc 1e8 cops
 for each "y" { // Itera aquest bloc 1e8 cops
 fes_alguna_tasca_dificil(x, y) // Això és el COS DEL LOOP i s'itera 1e16 cops (10.000.000.000.000.000)
 }
} 

A la GPU, el programador només especifica el cos del loop com a kernel i sobre quines dades iterar mitjançant el processament de geometria.

En programes normals és possible controlar el flux del programa fent servir sentències if-then-else i diverses formes de bucles. Aquestes estructures de control de flux han estat afegides a les GPUs recentment. Les escriptures condicionals es podien fer utilitzant una sèrie d'instruccions simples, però la iteració i la ramificació condicional no eren possibles.

Les GPUs recents permeten ramificació, però normalment amb una penalització al rendiment. La ramificació hauria de ser evitada generalment a iteracions internes, ja sigui a codi de CPU o de GPU, i diverses tècniques, com ara resolució de branques estàtiques, pre-computació i Z-cull^[1] es poden fer servir per a permetre ramificació quan no existeix suport de maquinari.

L'operació de map simplement aplica la funció donada (el kernel) a tots els elements del stream. Un exemple senzill és la multiplicació de cada valor del stream per una constant (incrementant el contrast d'una imatge). L'operació és simple d'implementar a la GPU. El programador genera un fragment per a cada pixel a la pantalla i aplica un fragment del programa a cadascun. L'stream resultant de la mateixa mida es emmagatzemat al buffer de sortida.

Alguns càlculs necessiten del càlcul d'un stream més petit (pot ser un stream de només 1 element) que pertany a un stream més gran. Això és anomenat una reducció de l'stream. Generalment una reducció es pot aconseguir en múltiples passos. Els resultats del pas anterior es fan servir com a l'entrada per al pas actual, i el rang sobre el que s'aplica l'operació és reduït fins que només queda un element de l'stream.

L'stream filtering (filtratge d'stream) és una reducció no uniforme. El filtratge involucra la supressió d'elements de l'stream basant-se en algun criteri.

L'operació de dispersió es defineix més naturalment al processador de vèrtex. El processador de vèrtex és capaç d'ajustar la posició del vèrtex, cosa que permet al programador controlar on es deposita la informació a la graella. Altres extensions són també possibles, com ara el control de la mida de l'àrea al que afecta el vèrtex.

El processador de fragments no pot realitzar una operació de dispersió directa, ja que la localització de cada fragment a la graella és fixada en el moment de la creació del fragment i no pot ser alterada pel programador. No obstant això, una operació de dispersió lògica pot a vegades ser modificada amb un altre pas de reunió addicional. Una implementació de dispersió primerament emetria tant un valor de sortida com una adreça de sortida. Una operació de reunió immediatament següent fa servir comparacions d'adreces per a veure si el valor de sortida s'ubica al slot de sortida actual.

El processador de fragments és capaç de llegir textures de forma aleatòria, pel que pot reunir informació de qualsevol cel·la de la graella, o múltiples cel·les a la graella, com es demani.

L'operació d'ordenació transforma un conjunt no ordenat d'elements en un conjunt ordenat d'elements. La implementació més comuna a GPUs és fer servir xarxes d'ordenació.

L'operació de cerca permet al programador trobar un element particular dintre de l'stream, o possiblement trobar veïns d'un element especificat. La GPU només fa servir per a accelerar la cerca d'un element individual, sinó que es fa servir per a executar múltiples cerques en paral·lel.

A una GPU es poden representar diverses estructures de dades:

• Arrays denses
• Arrays poc denses - estàtiques o dinàmiques
• Estructures adaptatives

• GPU

• http://www.gpgpu.org (anglès)
• Biblioteca C# de backpropagation escrita pera GPUs (anglès)
• Diapositives d'una presentació de física a una GPGPU d'ATI fetes per l'estudiant de grau de Stanford Mike Houston Veure p.13 per a una visió general del mapeig de tasques de programa convencionals a maquinari GPU. (anglès)