DISEÑO DE CONJUNTO DE INSTRUCCIONES Y

MICROARQUITECTURA, ENTREGA FINAL

SEMANA 7

David Andrés Munive Ríos C.C. 1036933609 Cod. 118292

DOCENTE:
Francisco Gonzales

MÓDULO:
Arquitectura del computador

Politécnico Grancolombiano
Facultad de Ingeniería
 INTRODUCCIÓN

Este trabajo está relacionado, con el trabajo colaborativo propuesto

por el docente Franciasco Gonzales, del módulo de Arquitectura del
computador; en el cual se requiere diseñar un microprocesador
apoyándonos en la plataforma Mars, que sea capaz de tomar como
entrada un número natural y como salida decir si es un número primo
o no, partiendo del diseño de un pseudocódigo, implementándolo en
un lenguaje sencillo de programación que en este caso es PSeInt. En
esta tercera entrega se adicionará al trabajo final el circuito
desarrollado en Logisim.
 OBJETIVO GENERAL

Aplicar los conocimientos adquiridos a lo largo de la carrera y durante

estas primeras tres semanas, en el diseño de un algoritmo capaz de
identificar si un número es primo o no e implementarlo en el diseño de
un microprocesador para dicha función.

OBJETIVOS ESPECÍFICOS

 Explicar cómo se diseñó el código para identificar si un número

es primo o no.
 Implementar dicho código en PSeInt.
 Identificar las instrucciones requeridas en Mars.
 Traducir el código de alto nivel a lenguaje ensamblador.
 Implementar el diseño en logisim.
 CONTEXTO DEL PROYECTO

Los números primos pertenecen al grupo de los números naturales, la

característica que lo define es que solo puede ser divisible por 1 y por
sí mismo, es decir que el resultado de su residuo o módulo debe ser
cero. Cabe anotar que el conjunto de números primos es un conjunto
infinito.
Actividad para realizar
En esta entrega final, vamos a implementar todo lo desarrollado a lo
largo de las anteriores entregas en un circuito de logisim.
 ALGORITMO EN PSEINT

VARIABLES
num: Esta variable es utilizada para almacenar el número ingresado por el usuario
count: La variable “count” se utiliza como contador de cantidad de módulos resultantes
iguales a cero. Por medio de esta variable se hace una comprobación cada vez que se
itera el condicional mientras, esta comprobación es si contador es mayor que 2, ya que si
antes de llegar al final del conteo se identifican dos módulos iguales a cero, quiere decir
que como mínimo serán tres sumando el del mismo número. Al saber eso podemos
romper el bucle mientras y ahorrarnos el resto de iteraciones innecesarias.
i: La variable “i” sirve como operador divisor para el número a determinar si es primo, esta
variable crece en una unidad con cada iteración.
INSTRUCCIONES MIPS NECESARIAS

Las instrucciones que vamos a necesitar para desarrollar este algoritmo en lenguaje de
máquina son:

add: la instrucción “add” se utilizará para realizar la suma de cada iteración en las
variables “i” y “count”.
div: esta instrucción se usará indirectamente para hallar el módulo de la división; al
ejecutar esta instrucción, el módulo de dicha división se almacenará en el registro
especial “hi”.
mfhi: move from hi register es la función de esta instrucción, la cual utilizaremos para
mover el dato del registro “hi” a un registro general y poder operar con él.
move: con esta instrucción moveremos registros entre ellos según sea el caso. Ejemplo
para mover “num” a “i” cuando lleguemos a la cantidad de más de dos módulos.
beq: Branch on equal, se usará para saber si un módulo es igual a cero y saltar a la
instrucción correspondiente.
bne: Branch no equal, si el módulo no es igual a cero, se saltará a la instrucción
correspondiente.
bgt, blt: Se usarán para preguntar si “i” menor que “num” y “count” mayor que dos,
respectivamente y saltar a la instrucción siguiente según sea el caso.
print_int: Con esta instrucción imprimiremos el número entero en cuestión.
print_string: Imprimiremos dos direcciones con cadenas de texto en memoria, si es
primo o no.

Nombre Mnemónico Parámetros Ejemplo Descripción

que recibe
Suma Add $1=$2+$3 add $1,$2,$3 Al registro $1 le
almacena el valor de la
suma de los registros $2
y $3
División Divide $hi,$low=$2/$3 div $2,$3 Divide el registro $2
entre el registro $3. El
cociente se almacena en
el registro especial $lo y
el residuo en $hi
Mover desde Move from hi $2=hi mfhi $2 Mueve el valor del
registro “hi” registro especial $hi a un
 registro de uso general.
Mover registro Move $1=$2 move $1,$2 Mueve datos entre
registros.
Condición salto Branch on if($1==$2) go to beq Prueba si dos registros
si hay igualdad equal PC+4+100 $1,$2,100 son iguales y salta a una
línea en concreto.
Condición salto Branch on not if($1!=$2) go to bne Prueba si dos registros
si no hay equal PC+4+100 $1,$2,100 son diferentes y salta a
igualdad una línea en concreto.
Condición salto branch on if($1>$2) go to bgt Prueba si un valor es
mayor que greater than PC+4+100 $1,$2,100 mayor que otro y salta a
una línea en concreto.
Condición salto branch on less if($1<$2) go to blt Prueba si un valor es
menor que than PC+4+100 $1,$2,100 menor que otro y salta a
una línea en concreto.
Imprimir entero print_int $a0 = integer to li $v0,1 Imprime en pantalla un
be move entero almacenado en el
printed $a0,$t0 registro $a0
syscall
Imprimir línea Print_string $a0 = address li $v0,4 Imprime una línea de
de caracteres of la $a0,label caracteres almacenado
string in syscall en memoria.
memory
Cargar Load $1=100 li $1,100 Carga a un registro un
inmediatamente inmediate valor
Cargar dirección Load address $1=Address of la $s1,label Carga una dirección de
de memoria label memoria a un registro
DETALLE DE INSTRUCCIONES A UTILIZAR

REGISTROS QUE SE VAN A UTILIZAR

Los registros son espacios en memoria donde se cargan valores, o direcciones de
memoria.

Nombre Tamaño Descripción

$t0 32 bits Registro de
almacenamiento temporal,
parámetro de entrada.
Número a identificar si es
primo
$t1 32 bits Registro de
 almacenamiento temporal.
Contador de iteraciones y
divisor.
$t2 8 bits Registro de
almacenamiento temporal.
Registro para almacenar el
módulo resultante y
comparador con cero.
$a0 8 bits Registro para cargar
dirección de memoria o
valor a imprimir
$v0 8 bits Registro para cargar la
acción necesaria para
systemcall

MODOS DE DIRECCIONAMIENTO
Los modos de direccionamiento que vamos a utilizar son:
Direccionamiento directo a registro: El resultado de una operación se almacena
directamente en un registro. Ej: add $1,$2,$3
Direccionamiento relativo a PC con desplazamiento: Al cumplirse una condición
evaluada, salta a una dirección indicada en la etiqueta “label”. Ej: beq $1, $2, label
Direccionamiento inmediato: Agrega una constante en la operación. Ej: addi $1,$2, 2

CÓDIGO EN LENGUAJE ENSAMBLADOR

1: .data
2: ing_num: .asciiz "\n Digite un número para saber si es primo o no: "
3: mensaje_inicial: .asciiz "\n El número "
4: mensaje_primo: .asciiz " es primo"
5: mensaje_no_primo: .asciiz " no es primo"
6: .text
7: main: li $v0 4
8: la $a0, ing_num
9: syscall
10: li $v0, 5
11: syscall
12: move $t0, $v0
13: li $t1, 2
14: loop: beq $t0, $t1, primo #llamado subrutina cuando es primo
15: div $t0, $t1
16: mfhi $t2
17: beqz $t2, no_primo #llamado subrutina cuando no es primo
18: addi $t1, $t1, 1
19: b loop
20: no_primo:
21: li $v0, 4
22: la $a0, mensaje_inicial
23: syscall
24: li $v0, 1
25: move $a0, $t0
26: syscall
27: li $v0, 4
28: la $a0, mensaje_no_primo
29: syscall
30: b exit
31: primo:
32: li $v0, 4
33: la $a0, mensaje_inicial
34: syscall
35: li $v0, 1
36: move $a0, $t0
37: syscall
38: li $v0, 4
39: la $a0, mensaje_primo
40: syscall
41: b exit
42: exit: li, $v0, 10
43: syscall

Listado HEXA del binario

BINARIO HEXA
00100100000000100000000000000100 24020004
00111100000000010001000000000001 3c011001
00110100001001000000000000000000 34240000
00000000000000000000000000001100 0000000c
00100100000000100000000000000101 24020005
00000000000000000000000000001100 0000000c
00000000000000100100000000100001 00024021
00100100000010010000000000000010 24090002
00010001000010010000000000010001 11090011
00000001000010010000000000011010 0109001a
00000000000000000101000000010000 00005010
00010001010000000000000000000010 11400002
00100001001010010000000000000001 21290001
00000100000000011111111111111010 0401fffa
00100100000000100000000000000100 24020004
00111100000000010001000000000001 3c011001
00110100001001000000000000110001 34240031
00000000000000000000000000001100 0000000c
00100100000000100000000000000001 24020001
00000000000010000010000000100001 00082021
00000000000000000000000000001100 0000000c
00100100000000100000000000000100 24020004
00111100000000010001000000000001 3c011001
00110100001001000000000001001000 34240048
00000000000000000000000000001100 0000000c
00000100000000010000000000001100 0401000c
00100100000000100000000000000100 24020004
00111100000000010001000000000001 3c011001
00110100001001000000000000110001 34240031
00000000000000000000000000001100 0000000c
00100100000000100000000000000001 24020001
00000000000010000010000000100001 00082021
00000000000000000000000000001100 0000000c
00100100000000100000000000000100 24020004
00111100000000010001000000000001 3c011001
00110100001001000000000000111110 3424003e
00000000000000000000000000001100 0000000c
00000100000000010000000000000000 04010000
00100100000000100000000000001010 2402000a
00000000000000000000000000001100 0000000c
01101001010001000010000000001010 6944200a
01100101011101000110100101100111 65746967
00100000011011100111010100100000 206e7520
01100101011011011111101001101110 656dfa6e
01110000001000000110111101110010 70206f72
00100000011000010111001001100001 20617261
01100101011000100110000101110011 65626173
01101001011100110010000001110010 69732072
00100000011100110110010100100000 20736520
01101101011010010111001001110000 6d697270
00100000011011110010000001101111 206f206f
00100000001110100110111101101110 203a6f6e
01000101001000000000101000000000 45200a00
11111010011011100010000001101100 fa6e206c
01101111011100100110010101101101 6f72656d
01100101001000000000000000100000 65200020
01110010011100000010000001110011 72702073
00000000011011110110110101101001 006f6d69
00100000011011110110111000100000 206f6e20
 01110000001000000111001101100101 70207365
01101111011011010110100101110010 6f6d6972

DISEÑO CIRCUITO EN LOGISIM

A continuación, veremos el circuito implementado en logisim.
 CONCLUSIONES

El lenguaje de máquina es poco intuitivo y descifrable, pero con los procedimientos

adecuados y el orden correcto de las instrucciones podemos implementar un algoritmo,
creado en lenguaje de alto nivel y poderlo reducir a un set de instrucciones que lo pueda
entender la máquina, acompañado del hardware adecuado para dichas instrucciones,
podemos notar el resultado a un nivel mas físico y perceptible, fuera del ámbito intangible
de la máquina.