benchmarking ps1/ps2 - Benchmark tra Playstation 1 e Playstation 2

BENCHMARKING PS1/PS2
Confronto tra l' architettura della Playstation 1
e l' architettura della Playstation 2
Progetto di Architettura degli Elaboratori – Prof. Leonardo Pasini
Corso di Laurea in Informatica – Scuola di Scienze e Tecnologie – Università di Camerino
Anno Accademico: 2011/2012
Indice :
1 Introduzione :.....................................................................................................................................4
1.1 Presentazione progetto & Scopo:...............................................................................................4
1.2 Organizzazione progetto :..........................................................................................................4
1.2.1 Compito svolto da ogni componente :...............................................................................4
1.2.2 Programmi utilizzati: ........................................................................................................4
1.3 Uso della documentazione:...................................................................................................4
2.Storia della Playstation......................................................................................................................5
3.Playstation 1 .....................................................................................................................................6
3.1 Lista Hardware...........................................................................................................................6
3.2 Unità di elaborazione.................................................................................................................7
3.2.1 Cpu R3000A......................................................................................................................7
3.2.2 Cop0...................................................................................................................................7
3.2.3 DMA (Direct Memory Access)..........................................................................................8
3.2.4 GPU (Graphic Processing Unit).........................................................................................8
3.2.5 MDEC(Motion Decoder)...................................................................................................9
3.2.6 GTE(Geometry Trasformation Engine/Cop2)...................................................................9
3.2.7 SPU(Sound processing unit)..............................................................................................9
3.3 Memoria:..................................................................................................................................11
3.3.1 Memoria Ram:..................................................................................................................11
3.3.2 Altri spazi indirizzati:.......................................................................................................11
3.3.3 Memoria Spu:...................................................................................................................11
3.3.4 Memory Card:..................................................................................................................11
3.4 Dispositivi di input/output :.....................................................................................................13
3.4.1 Lettore Cd-rom :...............................................................................................................13
3.4.2 Controller (pad) :..............................................................................................................13
3.4.3 Serial I/O :......................................................................................................................13
3.4.4 Parallel I/O :..................................................................................................................13
4.Storia della Playstation 2 :..............................................................................................................14
5.Playstation 2:...................................................................................................................................15
5.1 Lista Hardware:........................................................................................................................15
5.2 Emotion Engine:......................................................................................................................15
5.2.1-Funzioni varie e controllo flusso dati..............................................................................15
5.2.2 Il team "cpu+fpu+vu0".....................................................................................................16
5.2.3 Il team "vu1 / gs"..............................................................................................................16
5.2.4 Uniamo i due team...........................................................................................................16
5.2.5- VU0 - Vector Unit 0........................................................................................................17
5.2.6- VU1 - Vector Unit 1........................................................................................................17
5.3-Il Graphics Syntetizer..............................................................................................................18
5.4-SPU2........................................................................................................................................19
5.5-Collegamento a Internet..........................................................................................................19
6- Benchmark.....................................................................................................................................20
6.1 Definizione di benchmark:.......................................................................................................20
6.2 Scelta tra questi due test:.........................................................................................................20
6.2.1 Un’ulteriore precisazione:...............................................................................................21
6.3 Stress-Test:...............................................................................................................................21
6.4 Fase di compilazione del programma di benchmark:..............................................................21
6.5 Legalità :..................................................................................................................................22
6.6 Calcolo del tempo computazionale dell' algoritmo :..............................................................22
6.7 Test da eseguire :.....................................................................................................................23
2
6.7.1 Crittografia e Decrittografia:............................................................................................23
6.7.2 Lettura del Cd-rom :........................................................................................................23
6.7.3 Caricamento di un immagine :.........................................................................................24
6.7.4 Riproduzione del suono:..................................................................................................24
6.7.5 :Lettura e scrittura della memoria :..................................................................................24
6.8 :Conclusione e Risultati:..........................................................................................................26
6.9 :Motivazione dei risultati:........................................................................................................26
6.10:Ringraziamenti :.....................................................................................................................27
6.11:Bibliografia :..........................................................................................................................27
3
1 Introduzione :
1.1 Presentazione progetto & Scopo:
Si vuole presentare al pubblico presente le console della casa giapponese Sony “Playstation” e
“Playstation 2” , poiché entrambe utilizzano l'architettura MIPS che abbiamo studiato durante il corso
di “Architettura degli elaboratori” dell 'Università degli studi di Camerino.
Si vuole mostrare come le due console siano nate ed evolute nel tempo.
Successivamente si descriverà l'architettura hardware della Playstation e della Playstation 2.
Infine si concluderà mostrando, attraverso benchmark applicativi, le differenze sostanziali tra le due
architetture .
1.2 Organizzazione progetto :
Questo progetto è stato realizzato da 3 studenti del dipartimento di Informatica dell' università degli
studi di Camerino.
1.2.1 Compito svolto da ogni componente :
Lo studente Stefano Traini si è occupato della descrizione delle tappe fondamentali che hanno
portato alla creazione e alla realizzazione di queste piattoforme .
Lo studente Fabio Pagnotta ha gestito l' architettura della Playstation mostrandone tutte le
componenti hardware in tutte le loro sfaccettature .
Lo studente Alessandro Di Carlo ha descritto la struttura della Playstaton 2 facendo vedere nel
dettaglio le varie parti montate nella console .
Tutti e tre i componenti si sono impegnati nel realizzare i vari test e provandoli sulle relative
piattaforme.
1.2.2 Programmi utilizzati:
Per la videoconferenza sono stati utilizzati programmi come Teamviewer e Skype.
Per lo scambio di file sono stati utilizzati siti/programmi come Sendspace ,Google drive e Dropbox.
Oltre a questo si è usato un sito per lo scambio di codici sorgenti(Pastebin).
Per la compilazione si è usato GCC insieme al set di librerie PSXSDK.
Per la simulazione in locale dei test si è usato il software ePSXe160.
Per la presentazione si sono utilizzati software come Microsoft Powerpoint e Libreoffice Draw.
Per la relazione si sono usati programmi come Libreoffice Writer , Microsoft Word e Adobe Reader .
1.3 Uso della documentazione:
L' uso di questa documentazione è strettamente riservato per fini didattici e dimostrativi .
I creatori di questa documentazione si assolvono dalla responsabilità di un uso scorretto/improprio
della stessa.
4
2.Storia della Playstation
La prima idea di PlayStation nacque all’inizio degli anni ‘90 quando Nintendo, dopo il grande
successo della console SNES (Super Nintendo Entertainment System) a 16 bit, aveva cercato di
sviluppare una console che leggesse supporti magnetici come i CD-ROM. Il fallimento di Nintendo
nella costruzione di tali dispositivi era dovuto sia alla scarsa durabilità del supporto che essendo
magnetico era facilmente cancellabile, sia al rischio “pirateria” a cui era sottoposto.
Così Nintendo fu costretto ad appoggiarsi a progetti sviluppati da altre società: la Sony e la Philips.
La società Giapponese e quella Olandese avevano entrambe creato un’estensione del formato CDROM denominata “ CD-ROM/XA” che univa audio compresso, grafica e computer data e li rendeva
accessibili simultaneamente.
Nintendo scelse Sony per via di alcune collaborazioni precedenti che avevano instaurato un buon
rapporto tra le due società.
Nacque così il progetto SNES-CD che prevedeva di installare nelle console Nintendo un supporto
CD-ROM. Tuttavia anche la stessa Sony aveva in mente di ideare una console tutta sua che leggeva
sia supporti SNES che CD-ROM.
Nel maggio del 1991 al CES (Consumer Electronics Show) quando stava per essere presentato il
SNES-CD, Hiroshi Yamauchi (presidente della Nintendo) si accorse del progetto che aveva in mente
Sony, e così stracciò il contratto di unione Nintendo-Sony e annunciò la collaborazione con Philips.
Nella “terra del sol levante” questo fu visto come un oltraggio poiché una società giapponese
favoriva una società europea a discapito di una stessa società giapponese.
Dopo la disgiunzione Nintendo decise di buttare tutti i lavori fatti in quegli anni, invece Sony decise
di conservare i progetti svolti e continuare a sviluppare la sua console. Così Nintendo intraprese una
causa legale nei confronti della Sony ma il giudice negò l’ingiunzione e così nell’ottobre del 1991 fu
lanciata la “Sony Play Station” e ne furono prodotte 200 unità.
Un accordo del 1992 permetteva a Sony di montare un’entrata per le cartucce SNES e a Nintendo di
usare alcuni componenti hardware marchiati Sony. Tuttavia nel 1993 Sony realizzò che la tecnologia
SNES era ormai obsoleta e decise di mantenere il solo lettore CD-ROM.
Rinnovati hardware e software ormai a 32bit , e tolto lo spazio tra i nomi nacque nel 1994 la prima
PlayStation che fu lanciata in Giappone il 3 dicembre del 1994, mentre negli USA e in Europa nel
settembre del 1995.
Fu prodotta in diverse colorazioni e modelli, ed i principali sono:
- SCPH-100x che prevedeva un’uscita S-Video e una porta parallela I/O;
- SCPH-500x che rispetto alla precedente aveva eliminato l’uscita S-Video;
- SCPH-700x che esternamente era uguale alla precedente ma a livello hardware furono
apportate modifiche per ridurre i costi di produzione (questi furono i modelli più venduti);
- SCPH-900x che aveva lo stesso hardware della 700x ma esteriormente aveva eliminato la
porta parallela I/O;
- SCPH-300x o anche chiamata NetYaroze, era una console dedicata alla creazione di giochi
da parte dei non professionisti, infatti, potevano essere programmati giochi non più
grandi di 1Megabyte, che potevano essere usati solo sulla console in cui erano stati
creati;
- DTL-H100x e DTL-H120x rispettivamente di colore Blu e Verde, furono due console
destinate alle software-house per lo sviluppo dei giochi.
Nel 2000 Sony lanciò una versione più piccola della PlayStation, la PSone che differiva da quella
ufficiale per la grandezza e per la mancanza di porte parallele e seriali.
Prima della sua dismissione nel 2006 ne furono vendute oltre 104 milioni di unità.
5
3.Playstation 1
3.1 Lista Hardware
In questo paragrafo descriveremo il modello più comune di Playstation 1 in Europa ovvero il SCPH7002.
Questa console è composta dalle unità di elaborazione, dalla memoria , dai dispositivi di
input/Output e da un bus.
Architettura di John von Neumann
Le componenti computazionali sono :
• Cpu R3000A 32 bit RISC 33,8688 Mhz ,Instruction Cache 4kb,Data Cache 1kb
• Cop0
• Gpu (Graphic processing unit).
• Mdec ( Motion Decoder).
• Gte (Geometry transformation engine or Cop2 ).
• Spu (Sound processing unit).
Le memorie sono:
• Ram grande 2 Megabyte
• Video di dimensioni di 1 Megabyte
• Spu grande 512 Kilobyte
• Due memory card da 128 Kilobyte l' una (eventuali).
I dispositivi di Input/output sono :
• CD-ROM.
• Controller
• Serial ,Parallel I/O.
• Memory Card.
Il bus che permette di legare questi 3 componenti ha una velocità di 132 MB/s .
6
3.2 Unità di elaborazione
Le unità di elaborazione sono dispositivi atti a computare un certo input e restituire un output .
3.2.1 Cpu R3000A
La cpu rappresenta il cuore della elaborazione della Playstation 1.
Questa permette di lavorare con ordine di byte inverso (Little endian) .
Oltretutto è di tipo RISC , questo significa che questa ha un numero ridotto di istruzioni con un
tempo computazionale minore .
Per quanto riguarda la cache R3000A ha due memorie cache .
Una per i dati (1kb) e l' altra per le istruzioni (4kb).
Oltre a questo la cpu è dotata di una pipeline per l' elaborazione delle istruzioni la quale però delega
i problemi della sua gestione al programmatore.
Per lavorare con i dati, la cpu R3000A utilizza 32 registri (R0-R31 vedi bibliografia “Registri mips”) 3
(Program counter, High e Low i quali conterrano il risultato della divisione e moltiplicazione a 64 bit).
Esistono tre tipi di formato istruzione :
1 Tipo:I-type
Codice operazione
Reg. Sorgente
Reg. Destinazione
Indirizzo spostam.
2 Tipo:J-type
Codice operazione
Indirizzo di spostamento
3 Tipo:R-type
Cod Op.
Reg. Source
Reg.O
Reg.Destin.
Num. di shift
funzione
Ci sono tre tipi di istruzioni : Load &Store,Computaziali, Salto e Speciali.
Le istruzioni di load/store (LW ,LB,LBU,LH,LHU,LW,LWL,LWR,SB...vedi la voce della bibliografia
“istruzioni della cpu R3000A”) vengono rappresentate tramite il tipo I-type.
Le istruzioni Computazionali (ADD,ADDIU,SLTI,SLTIU,ANDI,ORI,XORI,LUI,ADD,ADDU.. vedi la voce
della bibliografia “istruzioni della cpu R3000A”)
vengono rappresentate sia con il tipo I-type e R-type.
Le istruzioni di salto(J,JAL,JR,JALR,BEQ,BNE,BLEZ,BGTZ.. vedi la voce della bibliografia “istruzioni
della cpu R3000A”)vengono rappresentate con tutte e tre i tipi.
Infine le istruzioni speciali(SYSCALL e BREAK vedi la voce della bibliografia “ istruzioni della cpu
R3000A” ) hanno un formato R-type .
Queste istruzioni però possono alcune volte generare eccezioni .
La parte della questa cpu che gestisce queste si chiama cop0.
3.2.2 Cop0
La cop0 permette di gestire la memoria (vedi paragrafo 3.2.4), eccezioni , interrupt di sistema e
breakpoint.
Per gestire questi 4 aspetti la cop0 utilizza 15 registri tra cui per 4 per il TLB, 5 per i breakpoint , 4 per
le eccezioni e altri 2 per descrivere l' hardware e la situazione della cop0.
Tra i registri del TLB abbiamo “un puntatore globale” (Index) un registro Random (che permette l'
accesso a una area di memoria casuale ma sicura) e TLBL/ TLBH (i quali descrivono una
conversione da indirizzo virtuale ad un indirizzo fisico).
Per una descrizione più dettagliata si veda il capitolo riguardante la memoria.
Ci sono due tipi di breakpoint : Breakpoint in fase di lettura dati e Breakpoint in fase di esecuzione.
Il primo tipo di breakpoint viene gestito tramite due registri ( BDA,BDAM)e il secondo viene usato
sempre tramite due registri (BPC,BPCM).
Il registro che abilita i due breakpoint è il DCIC.
Per quanto riguarda le eccezioni, il registro BADV e il CONTEXT conterrano l' indirizzo virtuale nel
quale è avvenuta l' eccezione (con l' unica differenza che CONTEXT contiene un campo che faciliterà
la conversione di BADV in un indirizzo fisico).
L' indirizzo di ritorno dell' eccezione è invece situato nel registro EPC.
Per capire che tipo è l' eccezione ( Interrupt hardware, eccezioni TLB, errore di accesso alla memoria
errore di bus, syscall invocata, breakpoint invocato, istruzione riservat, cop0 non utilizzabile,
overflow ) si usa il registro CAUSE .
Tra gli ultimi registri rimasti da descrivere spicca il registro Status, il quale permette di abilitare o
7
meno il cop0, di scegliere quale vettore di interruzione usare (in RAM o in ROM ), di stabilire se si
sta operando in kenel mode o in user mode e infine permette in user mode di cambiare la
convenzione sull' ordine dei byte.
Per conoscere la revisione e la versione del processore viene utilizzato un registro chiamato PRID.
Per poter caricare dei valori in questi registri si usa operazioni di load and store (LWC0 , STC0 )
oppure si utilizzano operazioni di copia tra registri della cpu e cop0 o viceversa( MTC0, MFC0).
Oltre a queste istruzioni vi ne una che permette di ristabilire i bit da un eccezione(RFE).
Per le istruzioni del tlb si guardi il paragrafo dedicato alla memoria .
3.2.3 DMA (Direct Memory Access)
Il Dma permette a qualunque dispositivo di interloquire direttamente con la memoria RAM (o
viceversa).
Esistono 7 canali che definiscono quale area di memoria virtuale definisce la trasmissione tra RAM
e un altro dispositivo.
Indirizzo
Canale
Dispositivo
Base
0x1f80_1080
0
MDECin
0x1f80_1090
1
MDECout
0x1f80_10a0
2
GPU(list+image data)
0x1f80_10b0
3
CD-ROM
0x1f80_10c0
4
SPU
0x1f80_10d0
5
Parallel input/output
0x1f80_10e0
6
GPU OTC(clear the ordering table)
Channel- 0x1f80_10f0:
Questo registro permette di abilitare un canale o l' altro .
Per abilitare un canale o un altro basta settare a uno il bit
3*(C+1) Dove C è il canale che vogliamo settare .
Ad esempio se vogliamo settare il canale della Spu il cui numero è 4 dobbiamo sommare 1 e
moltiplicare per 3 (3*5=15).
Address-(Base Address):
Questo registro rappresenta l' indirizzo del DMA (1 colonna).
Size-(Base Address+4):
La prima metà del registro (dal 31esimo bit al 16esimo) rappresenta il numero di blocchi che si
possono leggere .
La seconda metà del registro (dal 15esimo bit al bit 0) rappresenta la grandezza di ogni singolo
blocco .
Enable-(Base Address+8):
Permette di abilitare o disabilitare il DMA e di stabilire quale direzione stabilire
(Memoria → Dispositivo | Dispositivo → Memoria)
3.2.4 GPU (Graphic Processing Unit)
La gpu ha 1 mb di frame buffer nel quale vi risiedono i pixel e le varie primitive .
Oltre a questo megabyte di buffer la gpu contiene una texture cache di 2kb che permette di
incrementare le prestazioni della gpu.
Malgrado lo spazio messo a disposizione sia 1Mb non tutto viene dato alla gestione dello schermo .
Le risoluzioni supportate sono 256x240, 320x240, 384x240, 512x240, 640x240, 256x480, 320x480,
512x480 e 640x480.
Queste risoluzioni possono essere visualizzate interlacciate /non interlacciate e con formato del
colore a 24 bit o a 16bit ( di cui uno per la trasparenza).
Nel frame buffer i pixel sono rappresentati con 2 byte (fatta eccezione per la texture).
S BLUE GREEN RED
1
5
5
5
La comunicazione con la gpu avviene in due modi :
1. Tramite la cpu:l'utilizzo di 0x1f80_1814 (il quale registro si occupa di gestire la dimensione della
schermata video ecc.... ) e 0x1f80_1810 (il quale serve per la comunicazione dati ).
2. Tramite l' uso del dma (utilizzando il canale 2 per il trasferimento della lista e il canale 6 per la
cancellazione di tutta la lista vedi paragrafo sopra).
I poligoni a 4 vertici sono disegnati come due poligoni da 3 vertici.
I rettangoli come gli sprite sono disegnati più velocemente rispetto ai
8
poligoni
Le primitive texture sono contenute in delle page texture
(larghe 256x256 pixel nel formato di 15 bit ,
128x128 a 8 bit e 64x64 a 4 bit ).
Le primitive texture sono :Sprite e poligoni.
Come accennato prima possono usare tre tipi di formato .
1- 15 bit diretti (quello descritto precedentemente )
2- 8 bit CLUT(ha due indici da 8 bit,ciascuno che punta a una parte del colore nella CLUT)
3- 4 bit CLUT(ha quattro indici da 4 bit,ciascuno che punta a una parte del colore nella CLUT)
3.2.5 MDEC(Motion Decoder)
Questo decoder permette di decomprimere un file JPEG, in un formato decompresso (composto da
rgb) .
La MDEC è in grado di lavorare con blocchi 16x16 .
Per potersi interfacciare con il controller dobbiamo usare il dma attraverso il channel 0 e 1 (il primo
per i blocchi compressi e il secondo per i blocchi decompressi).
Per poter gestire questa unità ci sono due registri :
0x1f80_1820 – mdec0.
Questo registro definisce il formato del colore e la trasparenza applicata all' immagine decompressa.
0x1f80_1824 – mdec1
In lettura permette di sapere informazioni utili ad esempio se la MDEC è ancora in fase di
compressione o meno .
In scrittura permette il reset della MDEC.
3.2.6 GTE(Geometry Trasformation Engine/Cop2)
Questa unita è il cuore dell' elaborazione 3D .
Ha 32 registri per il controllo di un operazione (Control register) e altrettanti 32 per svolgere
operazioni(Data register).
Per lavorare con questi registri ci sono istruzioni che permettono lo scambio tra registri della cpu e
Data register della cop2 ovvero MFC2 e MTC2 ( viceversa ), mentre per lo scambio tra registri della
cpu e Control register le istruzioni sono CFC2 e CTC2 (viceversa).
Per eseguire le operazioni della GTE si usa COP2 con un valore come parametro che specifica il tipo
di istruzione da eseguire (vedi bibliografia “Comandi Ps1 GTE”).
-Rotazione di matrici .
-Traslazione di vettori.
-Prodotto tra vettori.
-Interpolazioni….
3.2.7 SPU(Sound processing unit)
Questa unità ha un buffer di 512Kb, gestisce 24 canali .
Per ogni canale viene applicato un filtro ADSR.
Questo permette di:
1- modificare la velocità con cui il volume arriva al massimo valore partendo da zero (AR -Attack
Rate)
2-di velocizzare o meno il tempo di discesa a un livello di mantenimento (DR- Decay rate).
3-decidere l' andamento dopo il livello di mantenimento (Crescita/Decrescita in modo lineare
/Esponenziale) (SR Sustain rate)
4-modificare la velocità di chiusura una nota. (Release rate Rr)
5-modificare il livello del volume .
Queste operazioni si possono effettuare modificando i registri:
0x1f90_1c00- 0x1f90_1d7f:Area dedicata ai canali.
In questo spazio abbiamo uno start address che permette di dire in quale indirizzo della memoria del
sound si trova il suono e tanti altri registri che permettono di modificare il volume ecc..(ADSR).
La spu oltre ad applicare un filtro su ogni voce permette di riprodurre una gamma di effetti nella
stessa voce tra cui Room ,Studio small , Studio medium e studio large.
Per definire da dove parte l'area di questi effetti si usa il registro 0x1f901da2.
Per la regolazione invece del volume degli effetti a livello globale si usano i registri 0x1f801d84 e
0x1f801d86.
9
Per regolare invece il volume del suono a livello globale si usano i registri 0x1f801d80 per il left e
0x1f801d82 per il right.
Per abilitare i canali si usa l' indirizzo 0x1f801d88( per le voci 0-15) e 0x1f801d8a( per le voci 16-23).
Se si vuole disabilitare i canali si utilizzano gli indirizzi 0x1f801d8c(per le voci 0-15) e 0x1f801d8e(per
le voci 16-23).
Per trasferire i dati dalla cpu alla memoria spu(senza dma) si utilizzano i registri hardware:
SPU_STATUS2(0x1f80_1dae)- il quale ci dice cosa sta svolgendo la cpu(fase di attesa , fase di
trasferimento).
SPU_ADDRESS(0x1f80_1da6)- il quale rappresenta l' indirizzo su cui scrivere i dati.
SPU_DATA(0x1f80_1da8)- il quale rappresenta il dato da scrivere .
SPU_CONTROL(0x1f80_1daa)- il quale oltre a svolgere l' abilitazione dell' spu si occupa dell'
abilitazione della scrittura dei dati .
Per gestire l'abilitazione della spu, degli effetti... si usa il registro control (0x1f801daa).
L' spu gestisce separatamente il volume del CD (attraverso l' utilizzo di registri
0x1f901db0,0x1f901db2,0x1f901db4,0x1f901db6 e le prime locazioni di memoria della spu).
10
3.3 Memoria:
3.3.1 Memoria Ram:
La Memoria ram è composta da quattro 512k da 60ns .
0x00000000-0x0000ffff Kernel(64k)
0x80000000-0x8000ffff Kernel(64k)
0xa0000000-0xa000ffff Kernel(64k)
0x00010000-0x001fffff
U.Memory(1,9Meg)
0x80010000-0x001fffff
U.Memory(1,9Meg)
0xa0010000-0xa01fffff
U.Memory(1,9Meg)
Kuseg Spazio di indirizzi 1.
Kseg0 Spazio di indirizzi 2 .
Kseg1 Spazio di indirizzi 3.
Questi 3 spazi puntano alla medesima area di memoria .
Kuseg punta direttamente alla memoria fisica.Questa memoria facilità l' accesso al kernel.
Kseg0 è un segmento memorizzabile.
Kseg1 è un segmento non memorizzabile.
Per convertire un indirizzo virtuale in un indirizzo fisico si usa il TLB.
L'indirizzo virtuale è composto da due parti : VPN(20bit) e OFFSET(12bit).
L' offset rimane invariato e Il VPN viene sostituito con un PFN (20bit) attraverso il TLB.
L' indirizzo fisico sarà formato poi dal PFN+OFFSET.
Per sfruttare questa funzionalità dobbiamo prima di tutto caricare il nostro “puntatore globale”
(Index).
Dopodichè viene caricato su TLB High e TLB Low i dati del TLB riguardanti il nostro puntatore
globale (tramite la TLBWI).
Ora nei registri tlbh e tlbl avremo il pfn e il vpn (con tanto di eventuale segnalazione di errori).
3.3.2 Altri spazi indirizzati:
Per la comunicazione con altri dispositivi si usano degli indirizzi di memoria virtuale.
Indirizzi
Spazio
Uso
0x1f00_0000-0x1f00_ffff
Parallel Port (64K)
Questi indirizzi permettono
la comunicazione tra unità periferiche esterne con
la ps1.
0x1f80_0000-0x1f80_03ff
Scratch Pad (1K)
Lo scratch pad non è altro che una cache dati .
0x1f80_1000-0x1f80_2fff
Hardware Register (8K)
Questi indirizzi permettono di andare a lavorare su
registri di unità di elaborazione esterne (vedi gpu
ecc.)
0xbfc0_0000-0xbfc7_ffff
Bios (512K)
Quest' area è dedicata alle syscall che permettono
di accedere al disco ecc.. .
3.3.3 Memoria Spu:
Indirizzi
Uso
0x00000-0x003ff(1Kilobyte)
Cd audio sinistro.(dati decodificati dopo l'elaborazione del volume)(16 bit per blocco)
0x00400-0x007ff (1Kilobyte)
Cd audio destro.(dati decodificati dopo l'elaborazione del volume ) (16 bit per blocco)
0x00800-0x00bff(1Kilobyte)
Canale 1 .
0x00c00-0x00fff (1Kilobyte)
Canale 3 .
0x01000-0x01008 (1Kilobyte)
Dati di sistema (8 byte )
0x01009-0x0xxxx-0x7ffff(520Kilobyte)
Dati del suono.
Dati degli effetti.
3.3.4 Memory Card:
Una memory card della ps1 possiede 128Kbyte EPROM.
Il tempo di lettura/scrittura è di 10kb/s e di norma supporta 15000 scritture .
Il file system della memory card è composto da 16 blocchi e ad ogni blocco corrisponde 64 frame
(16*64 = 1024 frame).
Ogni blocco è grande 8 Kilobyte e ogni frame a sua volta è grande 128 byte.
Il primo blocco descrive l' allocazione di ogni blocco .
11
Per ogni blocco si definisce se è usato o meno, se necessita di un altro blocco per descrivere un
salvataggio ec... .
Oltre a ciò definisce il product key di ogni blocco , il codice identificato della ps che ha registrato
tale salvataggio (il paese di export) e infine il codice identificativo del gioco salvataggio e un valore
di checksum(XOR code).
Il contenuto di ogni blocco è dato dal titolo (1 frame), l' animazione del salvataggio (3 frame) e i dati
(60 frame).
Per quanto riguarda la comunicazione tra CPU e memory card vi sono le syscall oppure si puo'
interagire con la memory card utilizzando i registri 0x1F801044 ,0x1F80104A (vedi la voce della
bibliografia “Registri comunicazione con memory card” ).
La trasmissione a livello elettrico è molto simile a quella del joystick.
12
3.4 Dispositivi di input/output :
3.4.1 Lettore Cd-rom :
Il lettore cd-rom ha due velocità 1x e 2x che permettono di lavorare a 176K/sec e a 352K/sec .
Per gestire il lettore cd-rom si usano 4 registri :
CDREG0(0x1f80_1800)-permette di inviare un comando , di richiederne il risultato, di leggere se il
trasferimento del comando è stato svolto correttamente e di conoscere il tipo del comando .
CDREG1(0x1f80_1801)-permette di scegliere il comando da inviare e di leggere l' eventuale comando.
CDREG2(0x1f80_1802)-permette di scegliere gli argomenti da inviare .
CDREG3(0x1f80_1803)-permette di gestire interrupt del cd(Data ready, command complete
acknowledge, end of data detected, error detected).
I comandi che vengono eseguiti sono di tipo:
-Sincronismo:Sync (0x00) Nop(0x01)
-Informazioni legate al cd :SetMode(0x0E permette di gestire la velocità..),Getparam(0x0F permette di
restituire informazioni riguardanti la modalità , lo status ecc..)
-Lettura dei dati:Setloc(0x02 inserisce la futura posizione della testina in una posizione),ReadN(0x06
legge i dati con interrupt), GetLocL(0x10 ritorna gli ultimi byte dell' ultimo settore), SeekL(0x15
sposta la testina sulla locazione settata da SetLoc)
-Gestione delle traccie audio:Play(0x03 permette di leggere i dati i quali vengono caricati sulla
spu),Forward and Backward (0x04 e 0x05 cambia la traccia) ,Mute and Demute (abilita e disabilita
streaming sulla spu), GetLocP(0x11 è l'equivalente di GetLocL per l'audio), GetTN(restituisce il
numero delle traccie audio), GetTD(0x14 restituisce la traccia corrente).
-Gestione del motore:Standby(0x07 permette di stoppare tutte le letture e scritture), Stop Motor (0x08
permette di stoppare il motore). Pause (0x09 equivalente di Standby solo che mantiene la posizione
della testina),Init(0x0A Mode=00,Standby)
-SottoTest:Test(0x19 esegue alcuni sottocomandi tra cui ritorno del codice di protezione e reset).
3.4.2 Controller (pad) :
La comunicazione tra Joypad e cpu è data dall' utilizzo delle syscall (InitPAD ,StartPAD ,....) oppure
dall 'utilizzo dei registri STATUS (0x1f801044), CTRL(0x1f80104A)e DATA(0x1f801040).
La comunicazione avviene tramite un clock con frequenza 250KHz.
La porta di comunicazione seriale è composta da 8 pin raggruppabili nei seguenti gruppi:
-Data : ritorna i dati delle memory card/pad.
-Comando :invia il comando da eseguire.
-Alimentazione :7Volt ,Massa e 3,6 Volt.
-Selezione :Seleziona quale pad/memory abilitare o meno .
-Clock :Permette una trasmissione sincrona.
3.4.3 Serial I/O :
La porta seriale permette di trasferire informazioni a un massimo di 256Kb.
La comunicazione con serial I/O avviene tramite registri o tramite syscall .
Questa comunicazione oltre a giocare in multiplayer permette anche di usare l' altra Playstation 1
come unità alternativa di elaborazione raddoppiando così la capacità di calcolo.
3.4.4 Parallel I/O :
La porta parallela in realtà viene considerata una porta di espansione .
Questa accede a tutto ciò che è connesso al bus .
Un utilizzo comune di questa porta è dato dal Gameshark (per trucchi) e Action Replay(per altri
dispositivi non ufficiali ).
Per comunicare con questa porta la Playstation 1 mette a disposizione 64Kb di indirizzamento (vedi
memoria).
Per una comunicazione più dettagliata vedi la voce della bibliografia “ Playstation 1 Comunicazione
Parallela”.
13
4.Storia della Playstation 2 :
Il concepimento della PlayStation2 fu molto meno travagliato e intrigante della sua precursora, infatti
il progetto nacque e fu sviluppato interamente nei laboratori di Sony. Rispetto alla versione
precedente fu integrato un supporto per la connessione ad internet, due porte USB per il
collegamento di mouse e tastiera, un lettore DVD che permetteva di avere più spazio di archiviazione,
in modo tale da migliorare la grafica e la longevità del gioco e mantenne la compatibilità con i giochi
della PlayStation 1.
Furono prodotte in diverse colorazioni ma le più note sono la versione “Black” e la versione “Silver”.
Il suo lancio avvenne nel 2000, ma svariati problemi quali l’elevato costo della console, tools di
sviluppo inadeguati e problemi di esportazione, influirono negativamente sulle vendite a tal punto
che prima del 2003 vennero vendute solo poche milioni di unità.
Tuttavia nel 2004 ci fu un incremento esponenziale delle vendite dovuto a tre fattori: il primo fu il
rilascio di nuovi tools di sviluppo per i giochi, il secondo fu l’incremento di titoli destinati ad un
pubblico adulto che portò la ps2 ad essere una console usata da tutta la famiglia e non solo dai
ragazzi, ed il terzo fu l’uscita della ps2 “slim”, una console con le stesse caratteristiche e prestazioni
ma più piccola ed economica rispetto alla “sorella maggiore”.
L’8 novembre 2012 Sony ha sancì la dismissione dal commercio della ps2 con un totale di oltre 153
milioni di unità vendute che la colloca prima in classifica per numero di vendite.
14
5.Playstation 2:
5.1 Lista Hardware:
L’architettura della Playstation 2 è molto complessa sotto molti punti di vista. Con questa relazione si
ha lo scopo di tentare una spiegazione di tale componentistica interna basata su un’architettura
MIPS III. La struttura della Playstation 2 segue la normale struttura di una macchina di Von Neumann
infatti è costituita da un unità di elaborazione data dalla CPU Emotion Engine, una GPU, una SPU ed
una CPU I/O. Dispone anche di diverse memorie come una RAM da 32Mb (Direct RDRAM),RAM
VIDEO da 4Mb,RAM I/O da 2Mb,RAM SPU da 2Mb, 2 memory card e 2 cache memory (CPU) da 16Kb
(per le istruzioni) e da 24Kb (per i dati). Dispone anche di dispositivi di I/O come CD-ROM/DVD,2
porte proprietarie per il controller (joystick),2 porte USB , un uscita Video, supporto
FireWire/Ethernet/Infrarossi.
5.2 Emotion Engine:
Il cuore della Playstation 2 è rappresentato da un processore Emotion Engine. L' Emotion engine è
un processore RISC sviluppato, congiuntamente da SCE e TOSHIBA, per eccellere in un solo tipo di
applicazione: VIDEOGIOCHI in 3D. Il motivo per cui l'emotion engine, cuore, della PS2 è "nato", è
quello di creare videogiochi in 3D estremamente complessi. Come si evince dalle specifiche tecniche
l'emotion engine è in realtà non una semplice CPU, ma bensì un sistema composto da tre processori
collegati tra loro da un bus dati a 128bit.Una CPU operante alla velocità di 300Mhz e coadiuvata da un
coprocessore matematico interno (FPU) dedicato ai calcoli in virgola mobile, ed affiancato da due
coprocessori VU0 e VU1(Vector Processing Unit).
Basata sull' architettura MIPS la CPU Sony/Toshiba è in grado di "esplodere" ben 6.2GFLOPS(bilioni
di istruzioni al secondo) e di gestire la bellezza di 66 milioni di poligoni al secondo ad empty.Ma da
dove deriva questa forza "bruta" nel calcolo poligonale di Emotion Engine?
Emotion Engine è una sorta di unione tra una CPU ed un DSP(processore di segnali digitali), la cui
principale funzione è quella di simulare complessi mondi tridimensionali. Ma che cosa è un DSP?
Un processore DSP, in poche parole, processa un grande quantitativo di dati ed esegue cicli di
calcoli per produrre un grosso flusso di dati in uscita. Velocità e banda passante, sono l'essenza nel
processare segnali digitali. Una delle più utili ed importanti caratteristiche dei moderni DSP e quella
di poter eseguire MAC(moltiplicare-accumulare) in un solo ciclo di clock. essi sono fondamentali ed
hanno un grande riscontro in una molteplicità di calcoli vettoriali.
L'Emotion Engine ha un totale di 10 FMAC(accumulatore per moltiplicazioni in virgola mobile), 1 nel
FPU, 4 nel coprocessore VU0 e 5 in VU1, ognuno dei quali può eseguire un operazione MAC in
virgola mobile a 32bit per ogni ciclo di clock.
Il secondo aspetto fondamentale di un processore DSP è la velocità della banda passante e la
quantità di memoria. L'emotion engine è pieno di piccole memorie caches posizionate in modo
strategico(SPRAM, le memorie per i dati e le istruzioni dei due coprocessori VU, etc.), nelle quali si
può accedere in un singolo ciclo di clock. Nell' emotion engine è presente un DMAC(controller di
accessi diretti alla memoria) a 10 canali che riesce a gestire più di 10 trasferimenti simultanei sui bus
a 16-64-128bit interni al processore. Si può quindi affermare che grazie al DMAC, che gestisce i
trasferimenti dati, gli altri componenti possono essere sfruttati completamente senza doversi
interessare dello smistamento dei dati.
Questi sono quindi i motivi principali per cui emotion engine, e quindi PS2, può gestire una così
grande quantità di poligoni, la capacità di eseguire molti MAC molto velocemente ed una gestione
della memoria molto efficace e dinamica.
L' Emotion engine può eseguire due tipi primari di calcoli ed uno secondario.
Calcoli geometrici: Trasformazione e traslazione vertici dei poligoni.
Calcoli simulativi delle leggi fisiche: IA, elasticità, gravità, collisione, incidenza del vento, etc.
5.2.1-Funzioni varie e controllo flusso dati
Ma quali elementi all'interno di Emotion Engine sono deputati a svolgere tali funzioni:
CPU+FPU: Programmi di controllo, flusso dati.
CPU+FPU+VU0: Calcoli matematici delle leggi fisiche (gravità, elasticità, etc).
VU1: Calcoli geometrici, trasformazioni e traslazione vertici poligoni.
15
Tralasciando il primo punto CPU+FPU, comuni ad altri sistemi andiamo ad analizzare ciò che rende
Emotion Engine così particolare e prestante.
5.2.2 Il team "cpu+fpu+vu0"
Questi tre elementi(CPU+FPU+VU0) formano un team in cui la CPU è l' elemento principale ed FPU e
VU0 ne estendono le capacità.FPU e VU0 sono collegati alla CPU da un bus dati a 128bit
indipendente, così da non dover appesantire e sfruttare quello principale.Il bus dati indipendente
permette alla CPU di attingere ai registri del coprocessore VU0 e permette allo stesso di riempirli
come un coprocessore standard MIPSIII.Importantissimo è anche la condivisione dei velocissimi 16K
di SPRAM della CPU, che consente lo sfruttamento da parte di entrambi delle strutture dati in essi
contenute.Questi 16K di SPRAM si possono considerare come un' area di lavoro ad alta velocità,
condivisa da CPU e VU0, dove i dati vengono processati per poi essere spediti verso altre sezioni.
5.2.3 Il team "vu1 / gs"
L' altro team importante è composto dal coprocessore VU1 e dal Graphic Synthesizer(comunicano
attraverso il GIF->Unità d'interfaccia grafica).Anche il VU1 ha un bus dati dedicato sempre a 128bit
che lo collega direttamente con il GIF.Il "team" VU1/GS però non è in stretto contatto come il "team"
CPU/FPU/VU0. VU1 e GS si devono intendere come "compagni uguali" in cui nessuno dei due
elementi può controllare l'altro.
5.2.4 Uniamo i due team
Unendo il lavoro di questi "team" si aprono diverse soluzioni per il loro sfruttamento da parte degli
sviluppatori. Per esempio potrà decidere di avere il primo team (CPU+FPU+VU0) al lavoro per
generare i listati di visualizzazione(serie di comandi che "dicono" al processore grafico Graphic
Synthesizer quali forme geometriche primitive disegnare, cosa ombreggiare, i bitmap da riprodurre,
etc.) ed in parallelo intanto il secondo team VU1 potrà processare lo sviluppo delle trasformazioni
geometriche, per poter poi insieme trasmettere i dati al GIF(Interfaccia Grafica) che a sua volta
li distribuirà al Graphic Synthesizer.
Oppure potranno procedere utilizzando il primo team (CPU+FPU+VU0) come una sorta di preprocessore che carica i dati dalla memoria principale, crea il codice di renderizzazione e
lo trasferisce al secondo team VU1 che può così generare il listato di visualizzazione finale da
"spedire" al Graphic Synthesizer tramite GIF.
16
Al di là dei 66 milioni di poligoni dichiarati(dato ottenuto allineando tutti e 3 i processori di emotion
engine, e sommato il tutto, rappresentano un dato grezzo ottenuto nella migliore condizione) ciò che
sorprende dell'emotion engine è il drammatico supporto al calcolo in virgola mobile da sempre
ritenuto la panacea della grafica poligonale. E' la mancanza di tale caratteristica nell'attuale
Playstation 2 a causare tutte le note disfunzioni estetiche.L'aspetto probabilmente più interessante
introdotto da Emotion Engine è l'impiego di un coprocessore VU0 deputato alla gestione della fisica
dinamica, così che tutti i giochi sviluppati per PS2 potrebbero raggiungere vette di realismo e
verosimiglianza stratosferiche. Unendo l'impiego delle curve di Bezier con la riproduzione digitale
delle leggi fisiche potrebbero fin da ora(2° generazione di games con i kit di sviluppo completi)
rappresentare la norma nei games PS2 così come lo è oggi l'impiego dei poligoni nei videogiochi.
5.2.5- VU0 - Vector Unit 0
Questa unità vettoriale agisce, come la FPU, da coprocessore per la CPU e quindi può essere
assimilata, come visto nel diagramma precedente, ad una delle pipeline logiche della CPU. Essa è
composta da:
• 32 registri da 128 bit per le operazioni su FP a singola precisione; 16 registri da 16 bit per le
operazioni su interi;
• una unità di load e store (LSU), una ALU per interi, un generatore di numeri casuali (RNG) ect;
- una cache per istruzioni e una per dati entrambe da 4 KB;
• 4 unità FMAC e una FDIV.
Le unità FMAC eseguono le operazioni basilari di moltiplicazione-accumulazione e di
minimo/massimo in un ciclo mentre l’unità FDIV esegue le operazioni più complesse (divisione,
radice quadra e suo inverso) con un minimo di 7 cicli e un massimo di 13 cicli (per l’inverso della
radice quadra). Oltre ad eseguire le operazioni di coprocessore per la CPU per le procedure più
complesse come ad esempio simulazioni fisiche, la VU0 riceve nella fase di rendering, tramite il bus
dedicato, vettori da 128 bit composti da 4 FP da 32 bit che l’unità di interfaccia della Vector Unit (VIF)
provvederà a scomporre nei 4 dati da 32 bit da inviare alle 4 FMAC perché li processino.
5.2.6- VU1 - Vector Unit 1
La VU1 è dotata di tutte le caratteristiche della VU0 con la differenza di una cache dati e istruzioni da
16 KB ciascuna in ragione della maggiore quantità di dati che deve trattare rispetto alla VU0 e di una
unità Elementary Functional Unit (EFU) che è composta di 1 FMAC e 1 FDIV come la FPU e che è
destinata alla computazione elementare geometrica. La VU1 può inviare la Display List alla GIF in tre
diverse modalità (o seguendo la terminologia Sony tramite tre differenti percorsi): tramite il bus
principale, direttamente dalla VIF oppure direttamente dalla cache dati della VU1. Come questi
trasferimenti avvengano non è comunque svelato dalla Sony ma sono stati predisposti per non
saturare con la gran mole di dati delle trasformazioni geometriche il bus principale. Le VU sono
governate tramite il bus principale (e il DMA che ne governa il traffico) da quella che viene chiamata
3D display list che sarebbe una struttura dati da 128 bit di cui 32 bit che costituiscono un codice ad
uso del VIF per identificare esattamente il tipo di dato e quale slot occupa. Di questi 32 bit, 8
identificano la dimensione del dato, 8 bit servono per identificare l’istruzione e 16 bit gli indirizzi. In
sostanza la 3D display list contiene una parte di informazioni circa le istruzioni (che dal VIF giungono
alla cache istruzioni tramite un bus a 64 bit) e una parte di dati su cui operare (che giungono alla
cache dati dal VIF tramite un bus a 128 bit). La cache istruzioni delle VU è da 64 bit che gli
17
consentono di ricevere le istruzioni per la VU in un pacchetto appunto da 64 bit che possono essere
suddivisi in due istruzioni da 32 bit (Upper Instruction e Lower Instruction) che sono eseguite in
parallelo da distinte subunità della VU. Queste unità sono chiamate Upper Execution Unit (composta
dalle 4 FMACs che operano su 4 dati da 32 bit in parallelo moltiplicazioni, addizioni, minimo, ect) e
dalla Lower Execution Unit (composta da ALU, LSU, RNG ect che eseguono le rimanenti istruzioni
come load e store da 128 bit, radice, le operazioni base da FPU, generazione numeri casuali e altre).
Le due unità sono evidenziate in blu e in verde rispettivamente nello schema della VU0. Questa
descrizione ci porta a comprendere perché la Sony si riferisca alle unità vettoriali come a
unità SIMD/VLIW. Sono VLIW in quanto assumono più istruzioni da elaborare in parallelo contenute
in pacchetti di dimensione fissa e sono SIMD perché processano più dati in parallelo organizzati in
vettori. La VU0, operando la maggior parte del tempo come coprocessore per la CPU MIPS III che
gestisce istruzioni da 32 bit, si suppone abbia un qualche meccanismo che gli consente di ignorare
le Lower Instruction anche se può comunque operare in 'modalità VLIW' eseguendo in parallelo le
due istruzioni di un pacchetto da 64 bit come la VU1.
Vediamo ora come collaborano le varie unità. La CPU e la VU0 (tralasciamo ora il ruolo della FPU) si
incaricano delle simulazioni di ambiente e producono una display list che costituirà i dati su cui
lavorerà la VU1. Siccome tali calcoli di simulazione d’ambiente sono piuttosto complessi e quindi
richiedono un tempo di esecuzione generalmente superiore a quello necessario alla VU1, i risultati
sono temporaneamente bufferizzati nella SPRAM. Dalla SPRAM essi possono essere poi inviati in
due diverse modalità: Seriale e Parallela. Secondo la connessione Seriale la display list è inviata
direttamente alla VU1 e in tal modo la VU0 agisce come preprocessore per la VU1 . Secondo la
connessione Parallela i dati della SPRAM possono essere inviati direttamente alla GIF che riceverà
contemporaneamente anche la display list della VU1 e deciderà come impiegarle in modo da
garantire al Graphic Synthesizer un afflusso costante di dati. Ad esempio potrebbe mescolare, per
particolari applicazioni, le display list della VU1 e della VU0. Questa flessibilità si traduce in pratica in
una concorrenza tra VU1 e Graphic Synthesizer più che in una collaborazione vera e propria come tra
VU0/CPU/FPU probabilmente in considerazione del fatto che il compito della VU1 per la generazione
delle più semplici operazioni geometriche è abbastanza indipendente dal controllo della CPU.
L’Emotion Engine, come tutti i dispositivi destinati ad applicazioni come giochi 3D o applicazioni
scientifiche, opera su un grande numero di dati con un relativamente ristretto flusso di istruzioni
(poche operazioni base ripetute più volte su dati sempre diversi). Questo fatto si traduce in una
minore permanenza dei dati nella cache dati rispetto al caso delle CPU tradizionali che invece
devono conservare nella cache i dati in attesa che tutte le istruzioni del flusso istruzioni li abbiano
processati. Quindi i processori destinati alle applicazioni suddette possono avvalersi di cache dati
relativamente piccole ma necessitano, per sostenere il flusso dati, di grande larghezza di banda.
Questo è appunto il caso del Emotion Engine che complessivamente ha un ammontare di cache
minore di un sistema PC ma grazie all’impiego del bus da 128 bit, al controller DMA e alla memoria
RDRAM può disporre di una grande banda. Ciò induce gli sviluppatori per PS2 ad un continuo
svuotamento della cache abbinato probabilmente ad hardware di prefetching non documentato
espressamente dalla Sony. Questo è un approccio diverso da quello cui sono abituati gli sviluppatori
di giochi 3D per PC che sanno di poter disporre di memoria nelle 3D card che hanno il compito di
immagazzinare grandi modelli o texture prima di visualizzarli. Inoltre la PS2 è dotata di 2 unità
vettoriali da 128 bit per floating point più la possibilità da parte della CPU MIPS di computazione su
128 bit di interi che le forniscono una capacità di esplicitare il parallelismo dei dati (SIMD) a livelli
non usuali.
5.3-Il Graphics Syntetizer
Il Graphics Syntetizer ha un ruolo fondamentale nell’architettura della Playstation 2. Infatti esso è un
processore grafico ad alte prestazioni. IL GS disegna primitive,come poligoni e righe, dal frame
buffer nella memoria locale basato sulle richieste del processore host. Contiene 4Mb di memoria
DRAM embedded per la memorizzazione di frame buffer,Z buffer e texture . Nel GS si hanno due
porte di configurazione: in questa configurazione, la porta del frame + Z buffer è indipendente dalla
porta texture.Ognuno ha una pagina di 8Kb e sono accessibili contemporaneamente. Questa
funzione legge informazioni sotto forma di immagine dalla memoria facendo la scansione del
segnale televisivo, esegue la conversione D / A ed emette il segnale video. Si hanno vari formati d’
output: NTSC/PAL/VESA. Il GS utilizza quattro tipi di dati nella memoria locale per il disegno:
1. Il Frame Buffer dove i pixel memorizzano il risultato di ciò che viene realizzato
2. Z buffer dove viene memorizzato il valore Z dei risultati del disegno
3. Texture buffer dove vengono memorizzati i dati relativi alla struttura dell’immagine
18
4. Clut buffer Memorizza la tabella “Color Look Up” usata quando la texture è un colore index
Il Graphics Syntetizer contiene anche numerosi registri che sono divisi in “General Purpose” e
“Registri Privilegiati”. I registri General Purpose sono principalmente utilizzati per impostare le
informazioni di vertice, l'ambiente di disegno e la trasmissione tra i buffer per le primitive di disegno.
Tutti loro sono registri di sola scrittura. Tra i registri che impostano l’ambiente di disegno, quelli con
i nomi nel formato “ XXX_1 e XXX_2 “ sono progettati per avere due contesti. I Registri Privilegiati
hanno una caratteristica diversa rispetto ai registri general purpose. Poiché i registri privilegiati e i
registri General Purpose vengono mappati in diversi spazi, i loro indirizzi di registro possono essere
duplicati. Inoltre, a differenza dei registri General Purpose, che hanno solo accesso in scrittura,
alcuni dei registri privilegiati possono avere accesso in lettura/scrittura.
5.4-SPU2
L’SPU2 è un processore di sintesi audio che è composto da due nuclei. L’SPU2 contiene anche una
memoria locale e un I/O esterno. I due nuclei sono adibiti a:
1. Riprodurre i suoni dati in input
2. Processare voci
3. Dare in output tutti i suoni processati
4. Eseguire l’elaborazione digitale di effetti
I nuclei (CORE1 e CORE 2) sono i componenti di base dell’ SPU2 ciascuno avente una funzione di
generazione di suono con 24 voci.Essi operano ad una frequenza di 36.864 MHz. Quando si imposta
lo stesso registro successivamente, la distanza prima dell’ operazione di scrittura del registro deve
essere di almeno 1Ts(l’unità di elaborazione è rappresentata come 1Ts). Se il registro è scritto in un
intervallo di tempo minore di quello specificato, le operazione dell’SPU2 diventano indeterminate; i
risultati attesi non possono essere ottenuti. Questo produce gravi effetti, soprattutto sul registro che
lavora come interruttore, come key-on e key-off. Il CORE0 e il CORE1 sono funzionalmente uguali e
operano indipendentemente. Sono collegati in modo tale che l’uscita del CORE0 è l’input del CORE1
e il suono misto finale viene emesso dal CORE1.
5.5-Collegamento a Internet
Una sostanziale differenza tra Playstation 2 e Playstation 1 è la possibilità,della prima,di potersi
connettere alla rete Internet. Tale connessione però può essere fatta solamente attraverso una
periferica esterna chiamata “Network Adaptor”. Erano disponibili due modelli di questa scheda - uno
con un modem dial-up e una Ethernet per la connessione ad Internet sfruttando la banda larga
(venduto solo in Nord America), e uno con solo un'interfaccia Ethernet (venduto in Europa e in altre
regioni).Un disco di avvio è incluso con l'adattatore di rete e installa un file sulla scheda di memoria
per le impostazioni di connessione che sono accessibili da parte di tutti.
La Playstation 2 può essere collegata ad Internet in vari modi:
1. Tramite connessione diretta con modem Ethernet
2. Tramite connessione condivisa (da usare con modem usb)
3. Tramite una connessione basata su un Router
4. Tramite una connessione wireless
19
6- Benchmark
6.1 Definizione di benchmark:
Per benchmark si intende un insieme di test software volti a misurare le prestazioni di un computer.
Esistono due tipi di test :
-Applicativo:
Questo tipo di test permette di computare operazioni che sono più user-friendly.
Ad esempio visualizzazione di una animazione , crittografia , riproduzione audio ecc.
Ognuno di questi test gestisce tante operazioni a livello hardware .
Un esempio è la riproduzione audio nella quale vediamo operazioni di trasferimento da ram a cpu e
poi da cpu a spu (incluso il segnale di start di audio e senza considerare l' uso del dma).
Pro:
Per l' utente i valori di questi test sono fondamentali .
Chi programma questi test è avvantaggiato in quanto per crearli usa librerie di medio/alto livello e
oltre a questo per poter cronometrare il tempo di esecuzione di un algoritmo non è necessario avere
un “cronometro” che abbia una sensibilità elevata.
Contro:
Essendo questo tipo di benchmark soggetto a molteplici fattori , l'indice risultante, non rappresenta
un indice della piattaforma ne tanto meno un indice che non ha alcun genere di variazione .
-Sintetici:
Questo tipo di test permette di analizzare le prestazioni di alcune caratteristiche di un determinato
hardware .
Pro:
Per l' utente i valori di questi test non sono molto significativi in quanto sono valori che
rappresentano le prestazioni di ogni singola componente dell' architettura hardware .
Questo tipo di algoritmo è efficiente dal punto di vista computazionale in quanto il codice eseguito
sarà più incentrato sul tipo di test da eseguire.
Se varia questo tipo di test i vari test applicativi che si appoggiano su quel determinato hardware
varieranno.
Contro:
L'indice risultante rappresenta un indice della hardware quindi necessita di un “cronometro” con
alta sensibilità.
Oltre a questo abbiamo che il tempo di programmazione di questo software sarà più lungo rispetto
al test applicativo.
6.2 Scelta tra questi due test:
Come tutte le scelte ,queste non si svolgono arbitrariamente bensì nel nostro caso si deve:
1- analizzare le componenti dell'/e architettura/e di riferimento .(vedi paragrafi precedenti)
2-cercare un compilatore (in un certo linguaggio ) con tanto di documentazione che permetta di
compilare per quel certo tipo di piattaforma .
3-cercare una documentazione relativa a una libreria e relativa direttamente all' uso dell' hardware.
4-decidere a che tipo di pubblico è rivolto questo tipo di benchmark .
Nel nostro caso le architetture di riferimento sono la Playstation 1 e Playstation 2 , il compilatore di
riferimento non è altro che GCC il quale permette di compilare per MIPS , le sdk che si appoggiano
su questo compilatore è PSXSDK e, infine, il tipo di pubblico a cui è rivolto questo benchmark è
generalmente un pubblico di gamer (quindi utenti della piattaforma).
Le funzionalità offerte dalla PSXSDK ci permette di avere un time counter con una sensibilità di
1/50 , 1/60 di secondo di conseguenza non è possibile usare benchmark sintetici in quanto il
tempo di esecuzione di un istruzione si aggira sui (1/7)*10^(-6) ( 5/frequenza di clock ).
Oltretutto l' utilizzo di benchmark sintetici non sarebbe oggetto di interesse da parte dei gamer a cui
ci rivolgiamo in quanto questo tipo di benchmark non è di primo utilizzo da parte dei giocatori.
Nonostante questo abbiamo voluto introdurre un test pseudosintetico che svolge alcune operazioni
a livello di cpu per poter vedere come la Playstation 1 computa operazioni di and or ecc... .
Per il resto abbiamo usato esclusivamente benchmark applicativi.
20
6.2.1 Un’ulteriore precisazione:
Il benchmark che svolgiamo non è proprio un benchmark tra la ps1 e la ps2 bensì un benchmark tra
la ps1 e la parte della playstation 2 che “simula” la playstation 1 (questa parte verrà argomentata più
approfonditamente alla fine del benchmark).
6.3 Stress-Test:
Alcuni dei test che vi presenteremo saranno degli stress test ovvero dei test ripetuti un numero N di
volte.
Le motivazioni per cui abbiamo scelto uno stress test (dove era possibile ) sono le seguenti:
1-per vedere fino a che input poteva computare la macchina in tempi ragionevoli .
2-per poter fornire un dato che si avvicinasse di più a tempi dell' ordine del secondo.
6.4 Fase di compilazione del programma di benchmark:
Una volta deciso il tipo di benchmark si tratta di cominciare a scrivere il sorgente e dopo averlo
scritto compilare il tutto tramite GCC.
Il nostro compilatore svolge le seguenti operazioni :
1-Compilazione e linkaggio con conseguente output di un file elf.
2-Conversione da formato elf a eseguibile per la ps1.
3- Creazione di un file system.cnf che permette di stabilire che quell' eseguibile andrà eseguito .
4-Creazione di una cartella che contiene l' eseguibile della ps1 e il file system.cnf.
5- Creazione di un file iso (con file system CDFS) dalla cartella precedentemente creata .
6-Conversione da file iso a file bin .
7-Creazione di un file cue che permette la masterizzazione del file bin.
8-Creazione del CD.
Per eseguire questo cd è necessario avere una ps1 modificata .
21
6.5 Legalità :
Quando si tratta di questi argomenti è doveroso precisare anche l' aspetto legale della questione .
Innanzitutto bisogna suddividere l' aspetto della legalità in 2 argomenti:
1-Uso delle sdk .
2-Uso della ps1 modificata .
Per quanto riguarda il primo punto abbiamo che le sdk non sono ufficiali (a differenza delle psy)
quindi non soggette ad alcun termine di licenza se non quelle di GNU GPL v2.
Per quanto riguarda l' uso di exploit e eventuali mod chip hardware vi è una legge descrive ciò.
“1) art. 171, comma 1: "È punito, se il fatto è commesso per uso non personale, con la reclusione da
sei mesi a tre anni e con la multa da euro 2.582 a euro 15.493, chiunque a fini di lucro: […]
f-bis) […] vende […] pubblicizza per la vendita o il noleggio, o detiene per scopi commerciali,
attrezzature, prodotti o componenti ovvero presta servizi che abbiano la prevalente finalità o l'uso
commerciale di eludere efficaci misure tecnologiche di cui all'art. 102-quater ovvero siano
principalmente progettati, prodotti, adattati o realizzati con la finalità di rendere possibile o facilitare
l'elusione di predette misure […]";
2) art. 102-quater: "1. I titolari di diritti d'autore e di diritti connessi nonché del diritto di cui all'art.
102-bis, comma 3, possono apporre sulle opere o sui materiali protetti misure tecnologiche di
protezione efficaci che comprendono tutte le tecnologie, i dispositivi o i componenti che, nel normale
corso del loro funzionamento, sono destinati a impedire o limitare atti non autorizzati dai titolari dei
diritti […]"
Fonte : http://www.tomshw.it/cont/articolo/modificare-le-console-e-legale/27709/1.html “
6.6 Calcolo del tempo computazionale dell' algoritmo :
Per calcolare il tempo richiesto da un certo algoritmo da noi eseguito abbiamo creato una funzione
che viene richiamata ogni 50/60 volte al secondo(in base a quale modalità usiamo PAL /NTSC).
In pratica il nostro software ogni 50 /60 volte al secondo incrementa un contatore .
Quando il programma deve eseguire un test non fa altro che resettare il contatore (in modo da
evitare problemi di overflow),esegue un test ,e dopodichè prende il contatore e lo divide per 50 /60 in
base alla modalità video.
22
6.7 Test da eseguire :
I test che il nostro programma esegue sono 5 :
1-Crittografia e Decrittografia.
2-Lettura di un CD-ROM
3-Visualizzazione di un immagine.
4-Riproduzione di un suono.
5-Lettura e scrittura sulla RAM.
Per ciascun test effettuato si sono calcolati i valori risultanti dal test sia in modalità NTSC che in
modalità PAL.
Ci siamo accorti che i due valori si discostavano nel primo algoritmo nella ps2.
Le ipotesi da noi supposte sono tra le più varie ma l' ipotesi più accreditata è la seguente :
Nel primo test si sfrutta molto la cpu per un lasso di tempo abbastanza ampio ,ciò può comportare
un’attesa maggiore per l' elaborazione di un interrupt esterno da parte della cpu.
Per risolvere questo problema abbiamo deciso di prendere i due valori e farne la media.
Oltre a questo abbiamo deciso di ripetere il test 10 volte in quanto abbiamo visto che il valore di
alcuni test variavano nel tempo .
Dopo aver svolto questo procedimento per ogni test abbiamo calcolato la media .
6.7.1 Crittografia e Decrittografia:
Questo tipo di test è uno stress test .
In questo test si usa una chiave(“INF A CAMERINO “) e un blocco da cifrare (“ONEKTWOK”) .
L'algoritmo usato per criptare e decriptare è il TEA (Tiny Encription Algorithm).
Abbiamo scelto quest' algoritmo in quanto usa operazioni di and or e Xor e oltretutto permette una
semplice implementazione su piattaforme hardware dotate di poca RAM .
Abbiamo notato che il tempo di crittografia e il tempo di decrittografia sono uguali in quanto i due
algoritmi svolgono le stesse operazioni seppur con valori diversi.
I valori ottenuti con la ps1 sono :
NTSC
5,449999
PAL
5,48
I valori ottenuti con la ps2 sono :
NTSC
4,533333
PAL
5,44
6.7.2 Lettura del Cd-rom :
Questo tipo di test è uno stress-test .
Questo test svolge la lettura di un file da 1Megabyte.
In questo test abbiamo costatato che ripetendo i test i valori cambiavo a causa probabilmente del
tempo di posizionamento della testina .
I valori medi ottenuti per la lettura di 1 Megabyte sulla ps1 sono :
NTSC
4,171666419
PAL
4,209999649
I valori medi ottenuti per la lettura di 1 Megabyte sulla ps2 sono :
NTSC
3,399999656
PAL
4,010000084
I valori medi ottenuti per la lettura di un settore su disco sulla ps1 sono :
NTSC
0,00841197
PAL
0,00864767
I valori medi ottenuti per la lettura di un settore su disco sulla ps2 sono :
NTSC
0,00698127
PAL
0,00823387
I Kilobyte letti ogni secondo sulla ps1 sono :
NTSC
233,5105677
PAL
231,4247431
I Kilobyte letti ogni secondo sulla ps2 sono :
23
NTSC
286,5851224
PAL
242,9420909
6.7.3 Caricamento di un immagine :
Questo test non è stress test(nel senso che non vengono tante immagini sullo schermo
consecutivamente) .
Il suo algoritmo prevede di caricare un’immagine da 116 Kb in memoria video e poi di visualizzarla.
In questo test nella ps1 abbiamo riscontrato una variazione di circa 0,03 secondi dovuta magari a
qualche ottimizzazione svolta dalla ps1 mentre nella ps2 l' andamento è rimasto costante.
I valori medi ottenuti per il caricamento di un immagine sulla ps1 sono :
NTSC
0,08500046
PAL
0,089999955
I valori medi ottenuti per il caricamento di un immagine sulla ps2 sono :
NTSC
0,06666678
PAL
0,07999955
6.7.4 Riproduzione del suono:
Questo test non è uno stress test ( nel senso che non viene caricato più di un suono).
Il suo algoritmo prevede di caricare un suono (grande 350k) dalla RAM (precedentemente caricato
dal disco) al buffer dell' SPU e successivamente di riprodurlo .
In questo test abbiamo visto che l' andamento dei valori ottenuti era costante sia nella ps1 che nella
ps2 .
I valori medi ottenuti per il caricamento di un suono dalla ram sulla ps1 sono :
NTSC
2,31666676
PAL
2,31999918
I valori medi ottenuti per il caricamento di un suono dalla ram sulla ps2 sono :
NTSC
1,85000078
PAL
2,20000055
I valori medi ottenuti per i byte letti ogni secondo sulla ps1 sono :
NTSC
155057
PAL
154834
I valori medi ottenuti per i byte letti ogni secondo sulla ps2 sono :
NTSC
163280
PAL
194170
I valori medi ottenuti per avviare la riprodurre un suono sulla ps1 sono :
NTSC
0,00000076
PAL
0,0000018
I valori medi ottenuti per avviare la riprodurre un suono sulla ps2 sono :
NTSC
0,00000078
PAL
0,00000055
6.7.5 :Lettura e scrittura della memoria :
Questo test è uno stress-test in quanto scrive e legge 1Mb di memoria dal registro di cpu alla
memoria e viceversa .
In questo test abbiamo deciso di scrivere/leggere un dato di 1Mb lungo tutta la memoria a causa di
problemi di ottimizzazione del codice del compilatore.
L' andamento dei tempi di esecuzione è rimasto costante durante il tempo.
I valori medi ottenuti per la scrittura di 1Megabyte sulla ps1 sono :
NTSC
1,33333376
PAL
1,340000018
I valori medi ottenuti per la scrittura di 1Megabyte sulla ps2 sono :
NTSC
PAL
24
1,11666678
1,34000055
I valori medi ottenuti per i byte scritti ogni secondo sulla ps1 sono :
NTSC
786432
PAL
782519
I valori medi ottenuti per i byte scritti ogni secondo
NTSC
939023
sulla ps2 sono :
PAL
782519
I valori medi ottenuti per la lettura di 1 megabyte dalla ram sulla ps1 sono :
NTSC
0,81666676
PAL
0,81999918
I valori medi ottenuti per la lettura di 1 megabyte dalla ram sulla ps2 sono :
NTSC
0,68333378
PAL
0,81999955
I valori medi ottenuti per i byte letti ogni secondo sulla ps1 sono :
NTSC
1283970
PAL
1278751
I valori medi ottenuti per i byte letti ogni secondo sulla ps2 sono :
NTSC
1534501
PAL
1278751
25
6.8 :Conclusione e Risultati:
Per poter dar un indice complessivo che rappresenti il rapporto tra le due architetture abbiamo
svolto la media tra i valori NTSC e PAL e dopo di ché, per ogni test, abbiamo seguito la seguente
funzione matematica :
−1)∗100 ;
( Vmax
Vmin
IndiceTest ( Vmax,Vmin )=
dove Vmax/Vmin può essere il valore della ps1/ps2.
Una volta ottenuto l'indice per ciascuno dei test , abbiamo effettuato una media tra tutti i test e
abbiamo ottenuto il seguente risultato :
n
∑ IndiceTest ( Vmaxi ,Vmini )
Media= i=1
=12,60
n
Totale:
12,6
Test 5-Lettura-2
9,78
Test 5-Lettura-1
8,87
Test 5-Scrittura-2
9,73
Test 5-Scrittura-1
8,82
Test 4-3
15,35
Test 4-2
19,25
Test 4-1
14,49
Test 3-1(Immagine)
Rapporto Ps1/Ps2
19,32
Test 2-3(Cd-rom)
13,89
Test 2-2(Cd-rom)
12,12
Test 2-1(Cd-rom)
13,11
Test 1-2(decript.)
9,49
Test 1-1(cript.)
9,59
0
2
4
6
8
10
12
14
16
18
20
Questo indice ci permette di dire che la Playstation 2 (con la cpu R3000A) è più performante rispetto
alla Playstation 1 del 12,60%.
6.9 :Motivazione dei risultati:
I seguenti risultanti si motivano con l'utilizzo di lettori CD-ROM più veloci in fase di lettura di SPU e
GPU più performanti .
Invariate rimangono invece la cpu R3000A e la ram da 2Mb .
26
6.10 :Ringraziamenti :
In conclusione è lecito ringraziare alcune persone che hanno permesso la realizzazione del progetto:
-Nicola Paoletti :coordinatore del progetto .
-Jacopo De Bernardinis: compositore dell'audio usato all' interno dell' applicativo di benchmark.
-Giuseppe Gatta : Creatore delle psxsdk (sdk per lo sviluppo di applicazioni per la Playstation 1).
6.11:Bibliografia :
“Sito del materiale“-http://benchps.altervista.org/
“Playstation 1”- http://it.wikipedia.org/wiki/PlayStation
“Playstation 1 Documentazione”- http://hitmen.c02.at/html/psx.html
“R3000A Manuale”- http://hitmen.c02.at/files/docs/psx/3467.pdf
“Istruzioni della cpu R3000A “-http://hitmen.c02.at/files/docs/psx/psx.pdf
“ Playstation 1 Comunicazione Parallela”- http://hitmen.c02.at/files/docs/psx/GS32Comms.htm
“Comandi Ps1 GTE” - http://hitmen.c02.at/files/docs/psx/psx.pdf
“Registri comunicazione con memory card”-http://rveach.romhack.org/PSXInfo/psx%20hardware
%20info.txt
“Registri mips”- http://it.wikiversity.org/wiki/ISA_e_Linguaggio_Assemby_MIPS#I_Registri_del_MIPS
“Playstation 2 “-http://it.wikipedia.org/wiki/PlayStation_2
“Fine produzione Playstation2” - http://games.hdblog.it/2012/11/08/editoriale-playstation-2-sony-dicestop-alla-produzione/
“PS2 Manuale di riferimento “- http://www.mcamafia.de/pdf/pdfref.htm
“ Descrizione Ps2 “ - http://www.lithium.it/articolo.asp?code=31&pag=14
“ Descrizione Ps2 parte 2 “ - http://www.lithium.it/articolo.asp?code=31&pag=15
“Definizione di benchmark “ -http://it.wikipedia.org/wiki/Benchmark_%28informatica%29
“Algoritmo TEA”-http://it.wikipedia.org/wiki/Tiny_Encryption_Algorithm
“Psxsdk” -http://code.google.com/p/psxsdk/
“Psxsdk Channel” - “irc.freenode.net channel:#psxdev “
“Epsxe”-http://www.epsxe.com/
27