PROFESSOR: Jordi Tubela, Edifici C6-119 jordit@ac-upc.

edu TEMA 1 Estructura de Von Neumann | | CPU MEM

| E/S

Classificaci; -Personals: Sobretaula, porttils,netbooks, tauleta---Servers: Correu, BBDD, supercomputadors, etc... -Integrats: Electrodomstics, cotxes, etc... JERARQUA DE NIVELLS APPS //Entorns de programaci// //ABI// //S.O.// //ISA// //H.W.// Compilaci-interpretaci. =>Exemple: Java. Alt Nivell ->Intrpret |->Alt Nivell->Compila->L.M. Mesures de Rendiment Temps d'execuci= nInstruccions/Programes*Cicles/Instrucci*Frequncia Guany de rendiment d'A respecte a B(Speed Up): RENDIMENT = 1/ TEMPS D'EXECUCI SPEED UP d'A respecte a B = TB/TA Mesures de Consum P = C*V^2*F Llei d'Ahmdal -Les millores de rendiment ve limitada per la part que no podem optimitzar. Temps d'execuci desprs de millora = Temps d'execuci afectat millora/ guany + Temps execuci no afectat. TEMA 2 Instruccions i tipus de dades bsics(MIPS) Introducci del ISA al MIPS MIPS s RISC->Reduced 32 bits(dades i@ a l'espai de memria) 2^10 = 1Kb 2^20 = 1Mb 2^30 = 1Gb <-8bits-> A B C D 4@ = 1 Word

REGISTRES 32 Registres de 32 bits $s0....$s7 $t0....$t9 $pc $sp $zero $a0....$a3 Instruccions addu $s0, $s1,$s3 OPERANDS EN MEMRIA -Instruccions Load/Store .bytes no rest .half mult. De 2 .word mult. De 4 -Declaraci de variables .data #variables globals a: .byte(8bits) 0 b: .half (16 bits)1 c: .word(32 bits)-2 d: .dword(64 bits)10 (per defecte, si no s'ha inicialitzat, tindr un valor de 0) MEM a_:0x10010000 00 XX b :0x10010002 c_0x10010004 01 00 FE FF FF FF d 0x10010008 0A 00 00 00 00 00 00 00

.dword es pot fer servir als problemes, per no al lab .dword .word part baixa(valor), part alta(valor)

.align 3 fora l'adrea perque sigui mul de 2 ^3 align.0 => elimina l'alineaci automtica de les variables .align 1 .align 2 |->desa l'element a 2 ^X .align 3 OPERANDS CONSTANTS li $s0, 1 #$s0 = 1->codifica en 16 bits constants grans (> 16 bits) lui $s0, hi(constant)-TRANSPARENT#$s0 = hi constant/0....0 ori $s0, lo(constant)-TRANSPARENT#$s0 = hi constant/lo constant Millor utilitzar: li$ s0, 0x12345678 .data a: .word -2 .text .globl main main: la $s0, a#$s0 =@a lw $s0, 0($s0)#$s0, contingut de a jr $ra Visualitzaci de memria MEM 12 34 56 78 AB ... @ 0 4 8 C 10 FORMAT LAB @ 0 MEM 78563412 .......AB

+0 78563412

+4 .......AB

+8 .........

REPRESENTACI NATURALS Binari pur: n bits:

Exemple: n = 4 1001 9/ 2 1 4/2 0 2/2 0 1 Rang[0.....2^n-1] Suma: addu $s0, $s1, $s2 #$s0, = $s1 +$s2 addiu $s0,$s1,inm#$s0 = $s1 + inm Sobreeiximent: Exemple; 9 1001 7 0111 -----10000 Resta: subu $s0, $s1,$s2 # $s0, = $s1-$s2 Exemple: 9-> 1001 1001 7->-0111-> +1001<-Ca2 -------------00010 10010 DECLARACIO VARIABLES N C: MIPS: n = 8 unsigned char a: a: .byte 0 n = 16 unsigned short b: b: .half 0 n = 32 unsigned int c; c:.word 0 n = 64 unsigned long long d: d:.dword 0 REPRESENTACI Z->Ca2

Exemple: 6 0110 -3 1101 --------10011 Rang; [-2^(n-1)......+2^(n-1)-1] Suma: addu addiu Sobreeiximent: Quan la suma de 2 nums. Del mateix signe i el resultat t signe oposat

Resta: subu Sobreeiximent: Quan restem 2 nums de signe diferent i el signe del resultat s oposat al signe del substraent. 7 0111 -(-2) -1110 ---------9 11001 REPRESENTACI de CARACTERS Ascii 7 bits [0][codi Ascii] Declaracio: char c = 'A', Mips: c: .byte 'A' Propietats: 'A'....'Z' ----codis ascii consecutius 'a'....'z'------codis ascii consecutius '0'....'9'------codis ascii consecutius El bit n< 5 serveix per canvia entre mins i majs. 0: majuscules, 1: minuscules Format de les instruccions 3 Formats bsics: R[CO][rs][rt][rd][shamt][co] I [co][rs][rd][.........inm........] J [co][.............@..................] salts -branch b // format I -jump j // format J a qualsevol adrea

PUNTERS Un punters una variable que serveix per accedir a una altre variable. Variables globals .data a:word b: ... Declaracio d'un punter C: MIPS int *p; int *p2; int var; short *p2; short b; .data p:.word 0 p2: .word var var: .word 0 p2: .word 0

OPERACIONS SOBRE PUNTERS -Inicialitzaci: C: p2 = &b MIPS: la $t0, b#$t0 = @b la $t1, p2#$t1 = @p2 sw $t0,0($t1)

MEM

P2: @

Apunta ab

B:

-Desreferncia: C: var = *p; //var = a

MIPS: la $t0, p #$t0 = @p lw $t0, 0($t0)#$t0 = @dada p lw $t0, 0($t0)#$t0 = *p = a la $t1, var sw $t0, 0($t1) MEM

//apunta a p: a: $t0 $t1 a: var

*p = 1;

li $t0,1 la $t1, p lw $t1, ($t1) sw $t0, 0($t1) MEM $t1 a: 1

VECTORS Tipus de dada estructurat, homogeni Declaraci en C: Declaraci en MIPS: .data V: .space 40 V2: .half -2,-1,0,1,2

int V[10]; short V2[5]; Operacions: Accs a un element ____= V[index] V[index] = ____

V: V[0] V[1] V[2] ... ... V[9] Es guarda en posicions consecutives de memria. Accs Aleatori: @V[index] = @V + index*bytes element Exemple: int V[10] int a; int i; 1) a = V[3] 2) a = V[i] 3) V[i+3] = a; 1)@v[3] = @V + 3*4; la $t0, V li $t1, 12 addu $t0, $t0, $t1 lw $t0, 0($t0) la $t1, a sw $t0, 0($t1) 2) =@V+i*4+3*4 =@V+12 +i*4 la $t0, V la $t1, i lw$t1, 0($t1) sll $t1, $t1, 2 addu $t0, $t0, $t1 lw $t0, 0($t0) la $t1, a sw $t0,0($t1) +EFICIENT li $t0, V lw $t0, 12($t0) la $t0, V+12 lw $t0, 0($t0) 3)@V[i+3] = @V +(1+3)*4 la $t2, a lw $t2, 0($t2) la $t0, V+12 #accedir a var a la $t1, i lw$t1, 0($t1) sll $t1, $t1, 2 addu $t0, $t0, $t1 sw $t2, 0($t0)

PUNTERS I VECTORS int *p; int V[10]; V: V[0] V[1] V[2] p = V;#vector tot sencer p = &V[3];#direccio determinada *p = -1; *(p+1) = 2;

V[3][-1] V[3][2] la $t0, p lw $t0, 0($t0) li $t1,2 sw$t1, 4($t0) EQUIVALENT A: la $t0,p lw $t0,0($t0) addiu $t0,$t0,4 li $t1,2 sw $t1,0($t0)

STRINGS Cas particular dels vectors, quan els elements sn carcters. C: charstr[5] = HOLA; MIPS: .data str: .byte 'H','O','L','A',0 .asciiz HOLA EXERCICIS RESOLTS Executar programa C en un onridnador x86 Tenim: un interpret Java escrit en MIPS un compilador en c a x86 en Java

un traductor MIPS a x86 escrit en x86 Exercici 1,7 Clock P1 P2 1,5 Ghz 2 Ghz CPI A 1 2 CPI B 2 2 CPI C 3 2 CPI D 4 2

a)CPI? A: 10% B: 20% C: 50% D: 20% Suma ponderada

CPI 1: 1*0,10+2*0,2+3*0,5+4*0,2 CPI 2: 2*0,1+2*0,2+2*0,5+2*0,2 b) Quin s ms rpid? Prog. Amb 10^6 inst. Exercici 2.4 A = 0x10010000 $t0 = 0x10010000 B = 0x10010004 $t2 = 0x10010008 C = 0x10010008 @ Contingut(byte a byte) 0x10010000 0x10010010 En Mars: 10010000 00 01 02 03...................0F 08 09 0A 0B 00010203

03020100

Lw $t1, 0($t0)#$t1 = Mw[0x1000000] = 0x03020100 lw$t3, 0($t2)#$t3 = Mw[0x10010008] = 0B0A0908 sw$t3,-8($t2)#Mw = Mw[10010008] = 0B0A0908 lw $t4,4($t0)#$t4 = $t4 = Mw[10010004] = 07060504 sw $t1,-4($t2)#Mw[10010004] = 03020100 sw $t4,0($t2)#Mw = Mw[10010008] = 07060504 Exercici 2.5 .data B1,B2,B3B4 A: .byte 0, 0, 0, 0, 0 $t1,->Mw[A+1] Com ficar aix en menys de 8 lnies? PROTOTIP: la $t0,A sb $t1, 1($t0) srl $t1, $t1, 8 sb $t1, 2($t0)#$t1 = 0,B4,B3,B2,B1 srl $t1, $t1, 8 sb $t1, 3($t0)#$t1 = 0,0,0,B2,B1 srl $t1, $t1, 8 sb $t1, 4($t0)#$t1 = 0,0,0,0,B1 Soluci Bona Soluci Extra la $t0, A la $t0, A sb $t1, 1($t0) sll $t2,$t1,8 srl $t1, $t1, 8 sw $t2, 0($t3) #$t2 = B3,B2,B1,0 sh $t1, 2($t0) srl $t1, $t1, 24 #$t1 = 0,0,0,B4 srl $t1, $t1, 16 sb $t1, 4($t3) sb $t1, 4($t0)

Exercici 2,29 char *punter c; short *punter h; int *punter i; long long *punter d; c)punter h++;// Grficament Punter h @

--- | |

Half <---/(+1) Half <---/ la $t0, punter h lw $t1, 0($t0) addiu $t1, $t1, 2 sw $t1, 0($t0) e)*punter i = *punter i+5;// Grficament Punter i; @ --- | | *punter i; int <--/ La $t0, punter; lw $t0, 0($t0) lw $t1,0($t0) addiu $t1, $t1,5 sw $t1, 0($t0) Exercici 2,32 char indx[100]; short meitat[100] int val[100],vec[10]; Tenim: i,j,k=>$t0,$t1,$t2 @V[index] = @V + index*numbyter = @val[5] = @val +5*4; la $t3, val+20 lw $t3, 0($t3)#val[5] la $t4, vec+40 lw $t4, 0($t4)#vec[10] addu $t0,$t3,$t4 NOTA ADICIONAL: i = val[5] + val[6] @val[6]= @val+6*4;<.Accs aleatori @val[6] = @val[5] +4<-accs secuencial

Exercici 2,32c) c = indx[i+val[j]]; la $t3,val sll $t4, $t1,2 addu $t3, $t3,$t4 lw $t3,0($t3) addu $t3, $t0,$t3 la $t4,indx addu $t3,$t3,$t4 lb $t2,0($t3) OPERACIONS LGIQUES I DESPLAAMENTS And $t2, $t1, $t0 Sll $t1, $t0,n andi $t1, $t0, 0x1234 [$t0]<-n Or $t2, $t1, $t0 ori Xor/xori nor Sra $t1, $t0,n [$t0]-> Srl $t1, $t0,n 0->[$t0] Sllu] srau >$t2,$t1,$t0(amb $t0[4:0] srlu ]

BOOLEANS BIT A BIT and or xor not && || ^^ ! & | ^ ~

SENTNCIES CONDICIONALS(slt/slti/sltu/sltiu) Instruccions de comparaci(<)<-Totes 4 Per als ENTERS: slt #$t0<$t1#P.exemple: slt $t2,$t0,$t1//$t2 = o s 0 o s 1 slti # $t0 < constant Per als NATURALS Instruccions de salt Salt Incondicional Beq $t0,$t1, etiq bne B etiq

if(a<b){ #slt $t2,$t0,$t1// amb a = $t0, b = $t1 #beq $t2,$zero,$t1//llavors, sino a++; b++; } else { b++;a++;}

IF-THEN-ELSE slt $t2, $t0, 4t1 beq $t2, $zero, sino LLAVORS b fi SINO: SINO FSI: MACROS < blt $t0, $t1, etiq// enters, si son naturals, afegir u <= ble >= bge > bgt Suposem que a = $t0, b = $t1 C: MIPS: if(a<b)a++; bge $t0, $t1, sino addiu $t0, $t0,1 b fsi else b++; sino: addiu $t1, $t1, 1 fsi: Si s complexa com if((a>b)&&(c<=d))//s'eval primer l'esquerra i desprs la dreta, tenint en compte el lazy code ble $t0, $t1, sino bgt $t2, $t3, sino llavors bfsi sino: if((a>b)||(c<=0)) bgt $t0, $t1, llavors bgt $t2, $t3, sino llavors llavors sino b fisi Efecte lateral:// No entra al temari (a>b) && (c++<=d)//s'evala i desprs incrementem (a>b) && (++c<=d)//incrementa i desprs evala

INSTRUCCIONS de SALT b etiq s de tipus I, perque el salt s relatiu al PC. El que calcula s la distncia que t que saltar.

SENTNCIES ITERATIVES while (condicio){ cos bucle; } mentre: avaluacio, condicio saltar fi_mentre sino cos bucle b mentre fi mentre

for(inicialitzaci, condici, sentencia){ cosbucle } inizialitzaci while (condicio){ cos bucle; sentencia; } do{ fer: cos bucle; cos_bucle }while (condicio); avaluacio_condicio saltar a fer si es compleix

TEMA 3 SUBRUTINES
Subrutines: Element de l'arquitectura LM d'un processador que implementa les accions/funcions dels LAN Tasca parametritzable(que pot calcular un resultat) que es pot referenciar en mltiples ocasions dins un programa. Es defineix una vegada i en cada s se salta a una funci. -Per valor(entrada) -Per referncia(entrada/sortida) acci: void funci: int f(int p1, int*p2){ cos funcio; return 1; } res = f(p1,&p2)

Macros: bxx move li la Adrea de retorn => res = f(); @ret =>res2 = f();

Crida a una funci: -Guardar @ret a $ra{ -$ra<-$pc(@ret) -$pc-<-@f }-jal f (nom de la funcio) Return d'una funci -Saltar a $ra->jr $ra Multinivell i Recursives, sn el mateix, perque quan fem el salt dona idugla cridar a una mateixa, que a una altre. IMPRESCINDIBLE UTILITZAR LA PILA!!!!

PAS DE PARMETRES /RESULTAT int f(int p1, int *p2, int *p3, int p4[]){// A travs de reg's, com $a0, $a1, $a2, $a3 } int a1, a2, res, *a3, v[10];// de manera consecutiva res = f(a1, &a2, a3, v)//(copia d'un enter, enter per ref(o copia de l'adrea),enter, adrea base) ->Per cada crida hi ha que fer un pas de parmetres

Ex: la $t0, a1 lw $a0, 0($t0) la $a1, a2 la $t0, a3 lw $a2, 0($t0) la $a3, v Pas del resultat: $v0(si fos un long long->$v1, per no l'utilitzarem) Mai farem un return d'un vector o un matriu CONTEXT DEL PROGRAMA -Els registres es divideixen en dos tipus: -Els que formen part del context=>la subrutina NO els pot modificar($s, $ra) -Els que no formen part del context =>la subrutina SI els pot modificar($t) //es poden utilitzar: si inici subrutina salvar reg de la pila restituir reg de la pila VARIABLES LOCALS int f(){//ELEMENTALS: REGISTRES(s'utilitzen desprs de l'execucio d'una subrutina) // ESTRUCTURATS: PILA int vl1; shor vl2; char *vl3; int vl4[10]; ... }

BLOC D'ACTIVACI -Tota la informaci que serveix per gestionar les subrutines que s'emmagatzemen a la pila. @retorn($ra) $s variables locals estructurades

MAI FER SERVIR ETIQUETES PER LA PILA!!!!! ACCS A VARIABLES LOCALS: despl($p) Exercici, Tradur a Mips el segent codi en C: int fact(int n){ int temp; if(n == 0) temp = 1; else temp = n*fact(n-1); return temp; }