Taller MIPS

Johan Nicolas Soler Hernández

Cod. 1810010162
Danny Jersson Ochoa Peralta
Cod. 1810010704
Juan David Ovalle Castellanos
Cod. 1810010853

Análisis y verificación de algoritmos

Gabriel Eduardo Ávila Buitrago

Institución Universitaria Politécnico Grancolombiano

Ingeniería de Sistemas
Bogotá D.C.
2021
1. Un programa emplea 60% de su tiempo de ejecución realizando aritmética de punto
flotante. De las operaciones de punto flotante en este programa, 90% se ejecutan en
ciclos paralelizables.

1
a. 0.6 = 1.42
(0.4+ )
2
b. Sabiendo que al tener dos procesadores llegamos a la conclusion de que es
menos aceleración: 1.37
c. Obtenemos porcentajes de tiempo en ejecución del 10%

2. Suponga que, con base en cuentas de operación (no hay gasto de tiempo en ellas),
una aplicación numérica usa 20% de operaciones de punto flotante y 80% de
operaciones integer/control (entero/control). El tiempo de ejecución de una
operación de punto flotante es, en promedio, tres veces más larga que otras
operaciones. Se considera un rediseño de la unidad de punto flotante para hacerla
más rápida.

a. Suponiendo la unidad de tiempo y usando la ley, llegamos a la conclusion

que la aceleración en punto FLOAT es 1.91
b. Calculando la aceleración max global obtenemos el 75%.
3. Para los siguientes fragmentos de código, realice la simulación respectiva en
lenguaje ensamblador (asuma los registros a usar):

a. :

add $t0 , $zero , 5

add $t1 , $zero , 8
add $t2 , $t0, $t1 #a+b
add $t2 , $t2, 10 # (a+b) + 10

li $v0, 1
move $a0, $t2
syscall

b. :

a.data
A: .word 5,8

.text
addi $t0 , $zero , 0
ld $t1, A($t0) # a = a[0]
addi $t0 , $zero , 4
ld $t2 , A($t0) # b = a[1]
add $t3 , $t1 , $t2 #c=a+b

li $v0 , 1
move $a0 , $t3
syscall
c. :

.data
a: .word 8
D: .space 10

.text

ld $s0 , a #a=8
addi $s1 , $zero , 0 #i=0
add $s2 , $zero , $zero # di

blt $s1 , $s0 , for

for:

add $t0 , $s0 , $s1 #a+i

sw $t0 , D($s2)
addi $s2 , $s2 , 4
addi $s1 , $s1 , 1

li $v0 , 1
move $a0 , $t0
syscall

blt $s1 , $s0 , for

d. :

.data
va: .word 3
vb: .word 2
D: .space 10

.text

ld $s0 , va #a=3
ld $s1 , vb #b=2
addi $s2 , $zero , 0 #i=0
add $s4 , $zero , $zero # di

blt $s2 , $s0 , for1

for1:

addi $s3 , $zero , 0 #j=0

add $s5 , $zero , $zero # dj
for2:

add $t1 , $s2 , $s3 #i+j

add $t1 , $t1 , $s0 # (i + j) + a
add $t1 , $t1 , $s1 # ((i + j)+ a)+ b
add $t2 , $s4 , $s5 # di + dj
sw $t1 , D($t2) # D[i+j] = i+j+a+b
addi $s5 , $s5 , 4
addi $s3 , $s3 , 1 #j+1

li $v0 , 1
move $a0 , $t1
syscall

blt $s3 , $s1 , for2

addi $s2 , $s2 , 1 #i+1

addi $s4 , $s4 , 4
blt $s2 , $s0 , for1
e. :

.data
va: .word 2
vb: .word 2

.text

ld $s0 , va
ld $s1 , vb

slti $t1 , $s0 , 2 # a < 2

beq $t1 , $zero , elseif
sub $s1 , $s1 , $s1
addi $s1 , $zero , 5
b endIf

elseif:
sgt $t1 , $s0 , 2 # a > 2
beq $t1 , $zero , else
sub $s1 , $s1 , $s1
addi $s1 , $zero , 10
b endIf

else:
sub $s1 , $s1 , $s1
addi $s1 , $zero , 15
b endIf

endIf:
li $v0 , 1
move $a0 , $s1
syscall
f. :

.data
va: 1

.text
ld $s0 , va

beq $s0 , 1 , case1

beqz $s0 , case2
b default

case1:
sub $s1 , $s1 , $s1
addi $s1 , $zero , 5
b exit

case2:
sub $s1 , $s1 , $s1
addi $s1 , $zero , 0
b exit

default:
sub $s1 , $s1 , $s1
addi $s1 , $zero , 10
b exit

exit:
li $v0 , 1
move $a0 , $s1
syscall
4. Convierta de Mips a C

a.

public void sumaToria(){

inr A[] = {1,5,6,7,8,5,6,...,45};
int a = 50
int i = 0;

while(a != 0){
int b = A[i];
int c += b;
b = A[4+i];
c += b;
i += 2;
a -= 1;
}
//C es la sumatoria de los primeros 50 numeros del arreglo
}

b.

public void (int n, int[] lista){

int list[] = lista;
int a = n + 4;
int b = n;
list[a]=b;
a = lista[a];
int c = a + b;
}
5. Cuál es el código en C de las siguientes instrucciones MIPS. Asuma que las
variables f, g, h, i y j están en los registros $s0, $s1, $s2, $s3 y $s4. Asuma que la
dirección del registro A y B están en $s6 y $s7.

a.

Public void quinto(A[],B[]){ //$s6 $s7

int f; //$s0
int g; //$s1
int h; //$s2
int i; //$s3
int j; //$s4

int m = f * 4;
m = A[f];
int n = g * 4;
n = B[g];
f = A[f];
int poinTemp = A[f+1];
m = A[f+1];
f = f + m;
B[g] = f;
}

b. Realmente solo pudimos reducir en una instrucción el procedimiento:

sll $t0, $s0, 2 # $t0 = f * 4

addi $t2, $t0, 4
lw $t0, 0($t2) # $t0 = A[f+1]
sll $t1, $s1, 2 # $t1 = g * 4
add $t1, $s7, $t1 # $t1 = &B[g]
lw $s0, 0($t0) # f = A[f]
add $t0, $t0, $s0 # f = A[f] + A[f+1]
sw $t0, 0($t1) # B[g] = A[f] + A[f+1]
6. Convierta las siguientes instrucciones a código hexadecimal:

• add $t5, $s3, $t2 = 0x026A6820

• slt $t2, $t5, $t1 = 0x01A9502A
• lw $s2, 0($s1) = 0x8E320000
• addi $t2, $0, $0 = 0x200A0000
• sw $t5, 12($s2) = 0xAE4D000C