|
|
|
![]() |
|
Strumenti |
![]() |
#161 | |
Senior Member
Iscritto dal: Nov 2002
Città: Singularity
Messaggi: 894
|
Quote:
__________________
echo 'main(k){float r,i,j,x,y=-15;while(puts(""),y++<16)for(x=-39;x++<40;putchar(" .:-;!/>"[k&7])) for(k=0,r=x/20,i=y/8;j=r*r-i*i+.1, i=2*r*i+.6,j*j+i*i<11&&k++<111;r=j);}'&>jul.c;gcc -o jul jul.c;./jul |Only Connect| "To understand is to perceive patterns" Isaiah Berlin "People often speak of their faith, but act according to their instincts." Nietzsche - Bayesian Empirimancer - wizardry |
|
![]() |
![]() |
![]() |
#162 |
Senior Member
Iscritto dal: May 2003
Città: Trieste, Pordenone
Messaggi: 920
|
Ora devo andare via e quindi purtroppo non leggerò la risposta prima di venerdì prossimo, comunque ho trovato un documento che sembra interessante sul sito della IBM. MPR-Cell-details-article-021405.pdf.
Purtroppo non ho avuto il tempo di leggerlo tutto, ma da un'occhiata veloce parrebbe che nè le SPU nè la PPU abbiano accesso diretto alla memoria, ma che tutto sia demandato all'EIB che a sua volta è collegato al MIC (che dovrebbe essere una specie di northbrige da quel che ho capito) che a sua volta accede alle XDR (...che al mercato mia madre comprò! ![]() Altro documento che sembrerebbe interessante è, secondo me, questo: http://www.realworldtech.com/page.cf...WT021005084318 Saluti e alla prox settimana!
__________________
buy here |
![]() |
![]() |
![]() |
#163 | ||
Senior Member
Iscritto dal: Oct 2002
Città: San Jose, California
Messaggi: 11782
|
Quote:
![]() Quindi e' possibile programmare il DMA direttamente dall'SPE in maniera esplicita senza passare dal controllore? Vorrebbe dire che teoricamente e' possibile simulare qualcosa di simile ad un "texture fetch" direttamente dall'SPE. Ecco il passo: Quote:
__________________
"We in the game industry are lucky enough to be able to create our visions" @ NVIDIA Ultima modifica di fek : 07-05-2005 alle 17:13. |
||
![]() |
![]() |
![]() |
#164 | |
Senior Member
Iscritto dal: Nov 2002
Città: Singularity
Messaggi: 894
|
Quote:
![]() Se non ricordo male l'idea è permettere di caricare blocchi di dati nella memoria locale delle SPE, in maniera simile a una cache, ma con istruzioni esplicite. In questo modo ad esempio per applicare una convoluzione ad un'immagine si carica la kernel con un'istruzione, poi con altre istruzioni si caricano i blocchi di pixel su cui il filtro sarà applicato. In questo modo il flusso di dati non deve passare per la PPE. Un'altra possibilità dovrebbe essere quella di copiare i dati nella memoria locale di un'altra SPE per eseguire istruizioni a catena (esempio, convoluzione + sogliatura). D'altra parte la possibilità di "saltare" la PPE è uno dei motivi che dovrebbero rendere il Cell molto efficiente nei compiti facilmente vettorializzabili.
__________________
echo 'main(k){float r,i,j,x,y=-15;while(puts(""),y++<16)for(x=-39;x++<40;putchar(" .:-;!/>"[k&7])) for(k=0,r=x/20,i=y/8;j=r*r-i*i+.1, i=2*r*i+.6,j*j+i*i<11&&k++<111;r=j);}'&>jul.c;gcc -o jul jul.c;./jul |Only Connect| "To understand is to perceive patterns" Isaiah Berlin "People often speak of their faith, but act according to their instincts." Nietzsche - Bayesian Empirimancer - wizardry |
|
![]() |
![]() |
![]() |
#165 | ||
Senior Member
Iscritto dal: Nov 2002
Città: Singularity
Messaggi: 894
|
Quote:
![]() EIB dovrebbe fare le veci del bus interno del processore, permettendo il transito dei dati dal controller di memoria alle varie unità. Infatti, se vedi il layout del processore, EIB è in contatto fisico con le 8 SPE e con la PPE. Quote:
![]()
__________________
echo 'main(k){float r,i,j,x,y=-15;while(puts(""),y++<16)for(x=-39;x++<40;putchar(" .:-;!/>"[k&7])) for(k=0,r=x/20,i=y/8;j=r*r-i*i+.1, i=2*r*i+.6,j*j+i*i<11&&k++<111;r=j);}'&>jul.c;gcc -o jul jul.c;./jul |Only Connect| "To understand is to perceive patterns" Isaiah Berlin "People often speak of their faith, but act according to their instincts." Nietzsche - Bayesian Empirimancer - wizardry Ultima modifica di Banus : 07-05-2005 alle 17:28. |
||
![]() |
![]() |
![]() |
#166 | |||
Bannato
Iscritto dal: Jun 2004
Messaggi: 4607
|
Quote:
![]() Quote:
Quote:
|
|||
![]() |
![]() |
![]() |
#167 | |
Senior Member
Iscritto dal: Oct 2002
Città: San Jose, California
Messaggi: 11782
|
Quote:
In effetti cosi' e' decisamente piu' flessibile. Il dubbio e': le istruzioni di caricamento sono bloccanti o no? Immagina un codice del tipo: 1) load kernel 2) load block_of_pixels 3) execute_kernel Se le due load sono bloccanti, mi inchioda l'intero SPE fino a che il trasferimento dei due blocchi di memoria, le istruzioni 1 e 2, non sono completati? Lo stesso "programma" su una GPU sarebbe eseguito su un certo numero di pipeline in contemporanea. quando la prima pipeline, ad esempio, manda il comando do fetch dalla memoria, invece di bloccarsi, ha della logica che parcheggia quel gruppo di pixel, e passa ad elaborare un altro gruppo di pixel. Quando il fetch e' completato, riesuma il primo blocco di pixel e lo elabora. Va detto che nelle GPU odierne tutte le pipeline eseguono lo stesso programma (shader), mentre su un Cell ogni SPE puo' eseguire programmi diversi. E' un'interessante differenza che forse spiega bene quanto una GPU abbia difficiolta' ad eseguire i compiti di un Cell e viceversa.
__________________
"We in the game industry are lucky enough to be able to create our visions" @ NVIDIA |
|
![]() |
![]() |
![]() |
#168 | |
Senior Member
Iscritto dal: Oct 2002
Città: San Jose, California
Messaggi: 11782
|
Quote:
A meno che non ci si programmi esplicitamente il PPE per compiere il lavoro di threading per nascondere le latenze degli accessi alla memoria, tutto il lavoro che in una GPU e' hardwired. Mi diventa sempre piu' chiaro il perche' abbiano affiancato una GPU al Cell nella PS3, un Cell si inchioderebbe al solo pensiero di dover processare pixel. Questa considerazione vale nell'ipotesi che i fetch siano bloccanti.
__________________
"We in the game industry are lucky enough to be able to create our visions" @ NVIDIA |
|
![]() |
![]() |
![]() |
#169 | |
Senior Member
Iscritto dal: Oct 2002
Città: San Jose, California
Messaggi: 11782
|
Quote:
__________________
"We in the game industry are lucky enough to be able to create our visions" @ NVIDIA |
|
![]() |
![]() |
![]() |
#170 | |
Bannato
Iscritto dal: Jun 2004
Messaggi: 4607
|
Quote:
Cioè la SPE esegue il suo bel codice nella memoria LOCALE (non può lavorare direttamente con la memoria centrale) e contemporanamente carica/scarica i dati elaborati con la memoria o le altre SPE. Ricorda che il Cell ha una banda spaventosa, sia con la memoria che con le altre SPE per mezzo un un bus ad anello. Non ricordo però se la banda sia sufficiente in caso di contemporaneo accesso al bus da parte di tutte e 8 le SPE (non mi sembra, era qualcosa tipo la metà). |
|
![]() |
![]() |
![]() |
#171 | |
Bannato
Iscritto dal: Jun 2004
Messaggi: 4607
|
Quote:
Il Cell è pensato come processore digitale multi-purpose ECONOMICO. Non va in competizioni con GPU da 500 Eur o processori da 1000 Eur. Quindi un suo utilizzo "solitario" è auspicabile per il suo target, e quasi certo su macchine di fascia bassa. Le GPU di cui parli sono processori estremamente complessi, spesso come e più del Cell in termini di transistor, quindi intrinsecamente costosi. Stai sicuro che se li possono eliminare pur mantenendo delle prestazioni "adeguate" lo faranno di certo. E il Cell dovrebbe garantire prestazioni onorevoli anche in ambiti ora di esclusiva pertinenza delle GPU. |
|
![]() |
![]() |
![]() |
#172 | |
Senior Member
Iscritto dal: Oct 2002
Città: San Jose, California
Messaggi: 11782
|
Quote:
![]() Per quanto ampia si la banda passante, non accadra' mai che fatta la richiesta al DMA per trasferire da memoria centrare un dato, questo dato sia immediatamente disponibile all'istruzione dopo. Ci sara' sempre e comunque una certa latenza, perche' se questa latenza non esistesse non avrebbe senso avere la memoria locale. Esempio: fetch [addr0], mem1 # memoria centrale, NON locale load r0, [addr0] add r0, r0, 10 La prima istruzione richiede un dato da memoria centrale a memoria locale, la seconda istruzione lo carica in un registro da memoria locale. E' matematicamente impossibile che al momento della seconda istruzione il dato sia gia' presente in memoria locale per via delle latenze. E' piu' probabile che accada una cosa del tipo: fetch [addr0], mem1 # esegui qualcosa qui mentre attendi il fetch wait [addr0] load r0, [addr0] add r0, r0, 10 Che esista una qualche istruzione di sincronizzazione che attende la fine del trasferimento e inchioda l'SPE. Il programmatore avrebbe sempre la possibilita' di eseguire un qualche lavoro utile fra il fetch e il wait. Se consideri che le GPU sono progettatr per nascondere automaticamente queste latenze quando processano i pixel (che accedono sempre alla memoria centrale per i fetch delle texture), hai un'ulteriore motivo per cui il Cell non potra' mai fare da GPU con prestazioni accettabile. Non e' costruito per questo lavoro.
__________________
"We in the game industry are lucky enough to be able to create our visions" @ NVIDIA Ultima modifica di fek : 07-05-2005 alle 18:03. |
|
![]() |
![]() |
![]() |
#173 | |
Senior Member
Iscritto dal: Oct 2002
Città: San Jose, California
Messaggi: 11782
|
Quote:
(Non hai letto nulla di quello che abbiamo scritto fin'ora, sembri un predicatore con la bibbia in mano che ripete la stessa filastrocca senza capire che vuol dire). L'NV40 piu' economico viene venduto a meno di 50 dollari e sono stati ingegnerizzati sample con costi di produzione inferiori ai 10 dollari. Ci rinuncio, tu non sai di che stai parlando.
__________________
"We in the game industry are lucky enough to be able to create our visions" @ NVIDIA |
|
![]() |
![]() |
![]() |
#174 | |
Bannato
Iscritto dal: Jun 2004
Messaggi: 4607
|
Quote:
Insomma si spezzettano i dati in blocchi da 256KB, si danno in pasto alla SPE che li elabora, e si copiano i risultati nella memoria centrale. Credo sia questa la filosofia di funzionamento delle SPE del Cell... |
|
![]() |
![]() |
![]() |
#175 | |
Senior Member
Iscritto dal: Nov 2002
Città: Singularity
Messaggi: 894
|
Quote:
fetch [block 1] (startup) fetch [block 2] kernel [block 1] fetch [block 3] kernel [block 2] ... e a regime quindi le SPE possono essere idealmente utilizzate al 100%. Ovviamente non sempre sarà così, ad esempio quanto il rapporto operazioni/dati è molto piccolo ci saranno comunque latenze, oppure quando il flusso di dati non è coerente. Vedo se riesco a trovare qualcosa di più preciso.
__________________
echo 'main(k){float r,i,j,x,y=-15;while(puts(""),y++<16)for(x=-39;x++<40;putchar(" .:-;!/>"[k&7])) for(k=0,r=x/20,i=y/8;j=r*r-i*i+.1, i=2*r*i+.6,j*j+i*i<11&&k++<111;r=j);}'&>jul.c;gcc -o jul jul.c;./jul |Only Connect| "To understand is to perceive patterns" Isaiah Berlin "People often speak of their faith, but act according to their instincts." Nietzsche - Bayesian Empirimancer - wizardry |
|
![]() |
![]() |
![]() |
#176 | ||
Bannato
Iscritto dal: Jun 2004
Messaggi: 4607
|
Quote:
Quote:
Ora ho capito perchè vogliono mettere i Cell anche nei televisori... Comunque fidati, se mai la Apple farà un MacMini con il Cell NON avrà una GPU. Pur di risparmiare 10$ toglierebbero anche il mouse (ops, l'hanno già fatto!). |
||
![]() |
![]() |
![]() |
#177 | |
Senior Member
Iscritto dal: Oct 2002
Città: San Jose, California
Messaggi: 11782
|
Quote:
Questa filosofia di funzionamento va benissimo per uno stream processor, ma e' l'esatto contrario di cio' che serve per una GPU. I pixel possono accedere in maniera random e incoerente virtualmente qualunque locazione in memoria centrale all'interno di una o piu' texture che possono essere grandi fino a 16/32 mb. Non sarebbe possibile copiare tutte le texture in memoria locale di un SPE per poi accedere da li'. Un pixel shader tipico e' una cosa di questo tipo: tex2d r0, s0, t0 # equivalente di un fetch a memoria tex2d r1, s1, t1 ... add r0, r0, r1 mov C0, r0 t0 e t1 sono gli indirizzi in memoria centrale (piu' o meno) e sono virtualmente ovunque. Un Cell con quel modello computazionale non sarebbe in grado di eseguire uno shader di questo tipo con prestazioni accettabili, perche' si ritroverebbe continuamente a trasferire blocchi da memoria centrale a locale e ad attendere le latenze, oppure la PPU dovrebbe essere programmata esplicitamente per nascondere in qualche modo queste latenze, e non e' un compito banale per una CPU gia' per se' piuttosto lenta.
__________________
"We in the game industry are lucky enough to be able to create our visions" @ NVIDIA |
|
![]() |
![]() |
![]() |
#178 | ||
Senior Member
Iscritto dal: Oct 2002
Città: San Jose, California
Messaggi: 11782
|
Quote:
![]() Quote:
__________________
"We in the game industry are lucky enough to be able to create our visions" @ NVIDIA Ultima modifica di fek : 07-05-2005 alle 18:16. |
||
![]() |
![]() |
![]() |
#179 | |
Bannato
Iscritto dal: Jun 2004
Messaggi: 4607
|
Quote:
Però credo lo stesso che un eventuale MacMini col Cell non avrà un GPU, anche perchè una GeForce 6800 (NV40, giusto?) a Roma non si trova a meno di 300Eur, altro che 10$!!! |
|
![]() |
![]() |
![]() |
#180 | ||
Senior Member
Iscritto dal: Oct 2002
Città: San Jose, California
Messaggi: 11782
|
Quote:
Quote:
__________________
"We in the game industry are lucky enough to be able to create our visions" @ NVIDIA |
||
![]() |
![]() |
![]() |
Strumenti | |
|
|
Tutti gli orari sono GMT +1. Ora sono le: 04:32.