b'\n_START_ARTICLE_\nGPGPU\n_START_PARAGRAPH_\nGeneral-purpose computing on graphics processing units (Computaci\xc3\xb3 de prop\xc3\xb2sit general sobre unitats de processament gr\xc3\xa0fic. GPGPU, tamb\xc3\xa9 conegut com a GPGP o GP\xc2\xb2) \xc3\xa9s la t\xc3\xa8cnica de fer servir GPUs per a fer computaci\xc3\xb3 en aplicacions tradicionalment tractades per la CPU. L\'addici\xc3\xb3 de fases programables i la precisi\xc3\xb3 m\xc3\xa9s gran en els pipelines de renderitzaci\xc3\xb3 ha perm\xc3\xa8s als desenvolupadors de software fer servir GPUs per a aplicacions no relacionades amb els gr\xc3\xa0fics. Mitjan\xc3\xa7ant l\'explotaci\xc3\xb3 de l\'arquitectura molt m\xc3\xa9s paral\xc2\xb7lela 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\xc2\xb7leles, molts problemes de computaci\xc3\xb3 poden ser accelerats considerablement.\n_START_SECTION_\nMillores a les GPU\n_START_PARAGRAPH_\nLa 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\xc3\xa0fiques. Es necessitaven alguns canvis abans que les GPGPU fossin viables.\n_START_SECTION_\nProgramabilitat\n_START_PARAGRAPH_\nEls vertex shaders i fragment shaders programables van ser afegits a les tasques gr\xc3\xa0fiques per a permetre als programadors de jocs la generaci\xc3\xb3 d\'efectes encara m\xc3\xa9s realistes. Els vertex shaders permeten al programador alterar atributs per v\xc3\xa8rtex, com ara la posici\xc3\xb3, 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\xc3\xadxel. Els fragment shaders programables permeten al programador la substituci\xc3\xb3, per exemple, d\'un model d\'il\xc2\xb7luminaci\xc3\xb3 diferent del que la tarjeta gr\xc3\xa0fica porta per defecte, habitualment sombrejat Gouraud. Els shaders han perm\xc3\xa8s als programadors de gr\xc3\xa0fics crear efectes de lent, despla\xc3\xa7ament de mapa, i profunditat del terreny._NEWLINE_La programabilitat dels pipelines ha evolucionat d\'acord amb l\'especficaci\xc3\xb3 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\xc3\xb3. L\'especificaci\xc3\xb3 DirectX 10 introdueix el Shader Model 4.0, que unifica l\'especificaci\xc3\xb3 de programaci\xc3\xb3 per a v\xc3\xa8rtexs, geometria i processament de fragments, permetent una adaptaci\xc3\xb3 millor del maquinari shader unificat.\n_START_SECTION_\nConceptes de programaci\xc3\xb3 GPGPU\n_START_PARAGRAPH_\nLes GPUs han estat dissenyades espec\xc3\xadficament per a gr\xc3\xa0fics i per aix\xc3\xb2 s\xc3\xb3n molt restrictives quant a operacions i programaci\xc3\xb3. A causa de la seva naturalsea, les GPUs nom\xc3\xa9s s\xc3\xb3n efectives abordant problemes que poden ser resolts fent servir processament de strems i el maquinari nom\xc3\xa9s es pot fer servir de certes formes.\n_START_SECTION_\nProcessament de streams\n_START_PARAGRAPH_\nLes GPUs nom\xc3\xa9s poden processar v\xc3\xa8rtexs i fragments independents, per\xc3\xb2 poden processar molts d\'aquests en paral\xc2\xb7lel. Aix\xc3\xb2 \xc3\xa9s especialment efectiu quan el programador vol processar molts v\xc3\xa8rtexs o fragments de la mateixa forma. En aquest sentit, les GPUs s\xc3\xb3n processadors de streams - processadors que poden operar en paral\xc2\xb7lel mitjan\xc3\xa7ant l\'execuci\xc3\xb3 del mateix kernel a molts registres d\'un stream al mateix temps._NEWLINE_Un stream \xc3\xa9s simplement un conjunt de registres que requereixen c\xc3\xa0lculs similars. Els streams ofereixen paral\xc2\xb7lelisme de dades. Els nuclis (kernels) s\xc3\xb3n les funcions que s\xc3\xb3n aplicades a cada element de l\'stream. A les GPUs, els v\xc3\xa8rtexs i els fragments s\xc3\xb3n els elements del stream i els shaders de v\xc3\xa8rtex i de fragments s\xc3\xb3n 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\xc3\xa9s podem llegir-lo de l\'entrada, fer-li operacions, i escriure\'l cap a la sortida. \xc3\x89s permissible tenir m\xc3\xbaltiples entrades i sortides, per\xc3\xb2 mai un tros de mem\xc3\xb2ria que pot ser reutilitzat per diverses GPUs al mateix temps o per qualsevol GPU en dos moments diferents. . _NEWLINE_La intensitat aritm\xc3\xa8tica \xc3\xa9s definida com el nombre d\'operacions realitzades per paraula de mem\xc3\xb2ria comunicada entre la unitat de proc\xc3\xa9s i la mem\xc3\xb2ria. \xc3\x89s favorable per a les aplicacions GPGPU tenir una intensitat aritm\xc3\xa8tica alta o en cas contrari, la lat\xc3\xa8ncia d\'acc\xc3\xa9s a mem\xc3\xb2ria limitar\xc3\xa0 la velocitat de c\xc3\xa0lcul._NEWLINE_Les aplicacions ideals GPGPU tenen grans conjunts de dades, alt paral\xc2\xb7lelisme i m\xc3\xadnima depend\xc3\xa8ncia entre elements de dades.\n_START_SECTION_\nTextures i stream\n_START_PARAGRAPH_\nLa forma m\xc3\xa9s comuna en qu\xc3\xa8 un stream arriba a una GPGPU \xc3\xa9s una graella 2D, ja que aix\xc3\xb2 s\'ajusta de forma natural amb el model de rendering constru\xc3\xaft a les GPUs. Molts c\xc3\xa0lculs s\'ubiquen de forma natural en graelles: \xc3\xa0lgebra de matrius, processament d\'imatges, simulacions basades en f\xc3\xadsica, i altres similars._NEWLINE_Ja que les textures es fan servir com a mem\xc3\xb2ria, les lectures de textures es fan servir com a lectures de mem\xc3\xb2ria. Algunes operacions es poden fer autom\xc3\xa0ticament fer servir les GPUs a causa d\'aix\xc3\xb2.\n_START_SECTION_\nNuclis (kernels)\n_START_PARAGRAPH_\nEls nuclis es poden interpretar com el cos dels bucles. Per exemple, si el programador estigu\xc3\xa9s fent operacions a una graella a la CPU, podria tenir codi similar al seg\xc3\xbcent:_NEWLINE_/* Pseudocodi */_NEWLINE__NEWLINE_x = 1e8_NEWLINE_y = 1e8_NEWLINE__NEWLINE_fes array de x per y_NEWLINE__NEWLINE_for each "x" { // Itera aquest bloc 1e8 cops_NEWLINE_ for each "y" { // Itera aquest bloc 1e8 cops_NEWLINE_ fes_alguna_tasca_dificil(x, y) // Aix\xc3\xb2 \xc3\xa9s el COS DEL LOOP i s\'itera 1e16 cops (10.000.000.000.000.000)_NEWLINE_ }_NEWLINE_} _NEWLINE_A la GPU, el programador nom\xc3\xa9s especifica el cos del loop com a kernel i sobre quines dades iterar mitjan\xc3\xa7ant el processament de geometria.\n_START_SECTION_\nControl de flux\n_START_PARAGRAPH_\nEn programes normals \xc3\xa9s possible controlar el flux del programa fent servir sent\xc3\xa8ncies 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\xc3\xa8rie d\'instruccions simples, per\xc3\xb2 la iteraci\xc3\xb3 i la ramificaci\xc3\xb3 condicional no eren possibles._NEWLINE_Les GPUs recents permeten ramificaci\xc3\xb3, per\xc3\xb2 normalment amb una penalitzaci\xc3\xb3 al rendiment. La ramificaci\xc3\xb3 hauria de ser evitada generalment a iteracions internes, ja sigui a codi de CPU o de GPU, i diverses t\xc3\xa8cniques, com ara resoluci\xc3\xb3 de branques est\xc3\xa0tiques, pre-computaci\xc3\xb3 i Z-cull es poden fer servir per a permetre ramificaci\xc3\xb3 quan no existeix suport de maquinari.\n_START_SECTION_\nMap\n_START_PARAGRAPH_\nL\'operaci\xc3\xb3 de map simplement aplica la funci\xc3\xb3 donada (el kernel) a tots els elements del stream. Un exemple senzill \xc3\xa9s la multiplicaci\xc3\xb3 de cada valor del stream per una constant (incrementant el contrast d\'una imatge). L\'operaci\xc3\xb3 \xc3\xa9s 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.\n_START_SECTION_\nReducci\xc3\xb3\n_START_PARAGRAPH_\nAlguns c\xc3\xa0lculs necessiten del c\xc3\xa0lcul d\'un stream m\xc3\xa9s petit (pot ser un stream de nom\xc3\xa9s 1 element) que pertany a un stream m\xc3\xa9s gran. Aix\xc3\xb2 \xc3\xa9s anomenat una reducci\xc3\xb3 de l\'stream. Generalment una reducci\xc3\xb3 es pot aconseguir en m\xc3\xbaltiples 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\xc3\xb3 \xc3\xa9s redu\xc3\xaft fins que nom\xc3\xa9s queda un element de l\'stream.\n_START_SECTION_\nStream filtering\n_START_PARAGRAPH_\nL\'stream filtering (filtratge d\'stream) \xc3\xa9s una reducci\xc3\xb3 no uniforme. El filtratge involucra la supressi\xc3\xb3 d\'elements de l\'stream basant-se en algun criteri.\n_START_SECTION_\nDispersi\xc3\xb3\n_START_PARAGRAPH_\nL\'operaci\xc3\xb3 de dispersi\xc3\xb3 es defineix m\xc3\xa9s naturalment al processador de v\xc3\xa8rtex. El processador de v\xc3\xa8rtex \xc3\xa9s capa\xc3\xa7 d\'ajustar la posici\xc3\xb3 del v\xc3\xa8rtex, cosa que permet al programador controlar on es deposita la informaci\xc3\xb3 a la graella. Altres extensions s\xc3\xb3n tamb\xc3\xa9 possibles, com ara el control de la mida de l\'\xc3\xa0rea al que afecta el v\xc3\xa8rtex._NEWLINE_El processador de fragments no pot realitzar una operaci\xc3\xb3 de dispersi\xc3\xb3 directa, ja que la localitzaci\xc3\xb3 de cada fragment a la graella \xc3\xa9s fixada en el moment de la creaci\xc3\xb3 del fragment i no pot ser alterada pel programador. No obstant aix\xc3\xb2, una operaci\xc3\xb3 de dispersi\xc3\xb3 l\xc3\xb2gica pot a vegades ser modificada amb un altre pas de reuni\xc3\xb3 addicional. Una implementaci\xc3\xb3 de dispersi\xc3\xb3 primerament emetria tant un valor de sortida com una adre\xc3\xa7a de sortida. Una operaci\xc3\xb3 de reuni\xc3\xb3 immediatament seg\xc3\xbcent fa servir comparacions d\'adreces per a veure si el valor de sortida s\'ubica al slot de sortida actual.\n_START_SECTION_\nReuni\xc3\xb3\n_START_PARAGRAPH_\nEl processador de fragments \xc3\xa9s capa\xc3\xa7 de llegir textures de forma aleat\xc3\xb2ria, pel que pot reunir informaci\xc3\xb3 de qualsevol cel\xc2\xb7la de la graella, o m\xc3\xbaltiples cel\xc2\xb7les a la graella, com es demani.\n_START_SECTION_\nOrdenaci\xc3\xb3\n_START_PARAGRAPH_\nL\'operaci\xc3\xb3 d\'ordenaci\xc3\xb3 transforma un conjunt no ordenat d\'elements en un conjunt ordenat d\'elements. La implementaci\xc3\xb3 m\xc3\xa9s comuna a GPUs \xc3\xa9s fer servir xarxes d\'ordenaci\xc3\xb3.\n_START_SECTION_\nCerca\n_START_PARAGRAPH_\nL\'operaci\xc3\xb3 de cerca permet al programador trobar un element particular dintre de l\'stream, o possiblement trobar ve\xc3\xafns d\'un element especificat. La GPU nom\xc3\xa9s fa servir per a accelerar la cerca d\'un element individual, sin\xc3\xb3 que es fa servir per a executar m\xc3\xbaltiples cerques en paral\xc2\xb7lel.'