ENTREGA 2 SEMANA 5
JESSICA TATIANA ZAPATA CHAVARRÍA
GRUPO B01
ARTURO CASTILLO
ARQUITECTURA DEL COMPUTADOR
INSTITUCIÓN UNIVERSITARIA POLITÉCNICO GRANCOLOMBIANO
INGENIERÍA DE SOFTWARE
BOGOTÁ – COLOMBIA
MARZO 2023
1. Tabla de contenido
Contenido
2. Introducción ................................................................................................................................ 3
3. Objetivo general .......................................................................................................................... 3
4. Objetivos Específicos ................................................................................................................... 3
5. Diseño del algoritmo ................................................................................................................... 3
5.1. Descripción del Algoritmo ................................................................................................... 4
5.2. IDE ....................................................................................................................................... 6
6. Instrucciones requeridas ............................................................................................................. 7
6.1. Instrucciones aritméticas .................................................................................................... 8
6.2. Instrucciones de comparación ............................................................................................ 8
6.3. Instrucciones lógicas ........................................................................................................... 8
6.4. Instrucciones de desplazamiento ........................................................................................ 8
6.5. Instrucciones de bits ........................................................................................................... 8
6.6. Instrucciones de entrada y salida ........................................................................................ 8
6.7. Instrucción For: ................................................................................................................... 8
6.8. Instrucción If/else:............................................................................................................... 9
7. Listado De Instrucciones. ............................................................................................................ 9
7.1. Nombre, Mnemónico, Parámetros. .................................................................................... 9
7.2. Descripción De Una Frase ................................................................................................... 9
8. Definición de registros. ............................................................................................................. 10
9. Descripción modos de direccionamiento .................................................................................. 11
10. Traducción del programa de alto nivel ................................................................................. 12
11. Codificación en HEXA ............................................................................................................ 14
12. ALU en Logisim. ..................................................................................................................... 15
13. Conclusiones.......................................................................................................................... 20
14. Bibliografía ............................................................................................................................ 21
2. Introducción
La globalización promueve progresos tecnológicos a grado económico, social, ambiental,
entre otros, accediendo al desarrollo de programa y conjuntos informáticos que facilitan la
utilización e ingreso a la información. El planeta digital ha avanzado vertiginosamente, el
hombre en su evolución cada vez requiere de más información; con la evolución de todo el
mundo tecnológico la arquitectura de los computadores debería estar al nivel para que los
computadoras sean cada vez más veloces en el procesamiento de la información, tengan
más capacidad de almacenamiento y superiores y más avanzadas funciones, así como
además destreza en la administración de los datos y mucha más grande fluidez en las redes
informáticas, razón por la cual se hace primordial el profundo entendimiento de las
arquitecturas de cómputo, con una proyección hacia el futuro que nos posibilite superar los
desafíos de las novedosas eras tecnológicas para beneficio de toda la raza humana.
3. Objetivo general
Diseñar un grupo de instrucciones y la microarquitectura de un procesador en el simulador
de diseño Logisim con el objeto de decidir si un número dado por un usuario es primo o no,
por medio de un algoritmo diseñado en pseudocodigo o en un lenguaje de alto nivel.
4. Objetivos Específicos
• Establecer si un número es primo o no.
• Diseñar el algoritmo en alto nivel.
• Definir la estructura del hardware mínimo para poder ejecutar todas las
instrucciones definidas en el conjunto de instrucciones.
• Diseñar la estructura de la microarquitectura de hardware sobre el simulador
Logisim.
5. Diseño del algoritmo
[Link]ón del Algoritmo
*Escrito en Apache NetBeans IDE 12.4*
import [Link]; // Se importa la clase para el ingreso de los datos.
public class numerosPrimos
{
/*---------------------------------------
Se declaran los Atributos
---------------------------------------*
public static int Dato = 0; //Almacena un valor entero.
public static String resultado = ""; //Tipo de datos primitivo de cadena.
public static int contador = 0; //Almacena un valor entero.
/*---------------------------------------
Se declaran los Métodos
---------------------------------------*/
static String esPrimo(int Dato) { // Gestión de la memoria.
for (int I = 1; I <= Dato; I++) { // Se emplea cuando conocemos el número de veces que
se ejecutará una sentencia o un bloque de sentencias.
if ((Dato % I) == 0) { //Se implementa la condición.
contador++; // Se utiliza para contar el número de ocurrencias de un suceso.
}
}
return resultado = contador == 2 ? "Es Primo" : "NO es Primo"; //Se declara el retornar un
valor. }
static void obtenerDatos() {
Scanner entrada = new Scanner([Link]);
[Link]("Ingrese el valor del numero Entero:"); //Se imprime por pantalla.
Dato = [Link](); //Almacena y devuelve el dato ingresado
[Link]();
}
/*---------------------------------------
Main
---------------------------------------*/
public static void main(String[] args) throws Exception {
[Link]("************************************************");
[Link](” Es Numero Primo? ");
[Link]("************************************************");
obtenerDatos();
[Link]("El Numero " + Dato + " " + esPrimo(Dato)); //Nos muestra el resultado
si el número es primo o no
}
}
[Link]
Se pueden apreciar los métodos obtenerDatos() y esprimo(), el primero se encarga de pedir
al usuario por consola el dato a analizar, el segundo se encarga de la lógica obteniendo su
modulo para saber si es primo o no.
A continuación, se aprecia el Main donde se hace el llamado a los métodos y la consola con
el resultado donde muestra que 11458 no es primo:
6. Instrucciones requeridas
Los tipos de instrucciones requeridas para la solución del problema son:
[Link] aritméticas
Son efectuadas por la ALU y suelen cambiar los flags o indicadores de condición: add:
suma, add with carry: suma con acarreo, subtract: resta, subtract with borrow: resta
teniendo en cuenta el adeudo anterior, increment: incrementa en 1 un valor, decrement:
decrementa en 1 un valor, multiply: multiplica, divide: divide, extend: aumenta el operando
de tamaño, negate: cambia de signo, absolute: valor absoluto. [1]
[Link] de comparación
compare: resta los dos operandos, pero no almacena el resultado, solo modifica los
flags, test: compara un cierto valor especificado con el 0.[1]
[Link] lógicas
Realizan operaciones booleanas "bit a bit" entre dos operandos. Como las
aritméticas también modifican los flags, and: el "y" lógico, or: el "o inclusivo"
lógico, xor: el "o exclusivo" lógico, not: la negación lógica. (complemento a 1, no
confundir con el cambio de signo "negate" que es el complemento a 2). [2]
[Link] de desplazamiento
Pueden ser aritmético o lógico y pueden incluir o no rotaciones. Pueden ser de
izquierda a derecha, shift: desplazamiento aritmético o lógico, rotate: rotación con o
sin acarreo.
[Link] de bits
Comprueban un bit del operando y su valor lo reflejan en el indicador de cero.
Pueden poner un bit a 0 o complementarlo, bit test: comprueba un bit, bit clear:
comprueba un bit y lo pone a 0, bit set: comprueba un bit y lo pone a 1. [1]
[Link] de entrada y salida
Son instrucciones de transferencia salvo que el origen/destino de dicho flujo es un
puerto de un dispositivo de entrada y salida. input o read: permite leer información
de un puerto y trasladarla a memoria principal, output o write: permite escribir
información en un puerto de un dispositivo, est i/o: lee información de control de un
periférico, control i/o: envía información de control hacia un periférico. [4]
[Link]ón For:
Los ciclos for son unas estructuras de control cíclica, nos permiten ejecutar una o
varias líneas de código de forma iterativa, pero teniendo cierto control y
conocimiento sobre las iteraciones. [4]
[Link]ón If/else:
La instrucción if/else permite controlar qué procesos tienen lugar, típicamente en
función del valor de una o varias variables, de un valor de cálculo o booleano, o de
las decisiones del usuario. [4]
7. Listado De Instrucciones.
Instrucción Detalle
li Se da el valor al registro
add Instrucción aritmética de suma
sumabeq Instrucción condicional si un valor es igual a otro
Div Instrucción aritmética de división
mfhi Mueve registro $hi a otro registro
addi Suma inmediata de un registro con una constante
[Link], Mnemónico, Parámetros.
NOMBRE MNEMONICO EJEMPLO DESCRIPCION
load li li $1,100 Cargar inmediatamente en elregistro
immediate
Adittion add add $1,$2,$3 Sumar $t2 + $t3 y almacenar en$t1
branch on beq beq $1,$2,100 Comparativo entre registros $t0$t1
equal
Divide Div div $2,$3 División directa
move from hi mfhi mfhi $2 Copiar el registro especial
add immediate addi addi $1,$2,100 “inmediato” Significa un
numeroconstante
[Link]ón De Una Frase
PARÁMETRO DETALLE
li $s1,5 Carga en $s1, el numero a testear si es primo o no
li $s2,0 Carga el registro $s2 con cero
li $t0,1 Carga el registro temporal $t0 con 1
li $t1,0 Carga el registro temporal $t1 con 0
li $t2,0 Carga el registro temporal $t2 con 0
add $s3,$s1,1 Suma $s1 +1 y lo guarda en $s3
beq $t0,$s3,esprimo Salto a “esprimo” si $s3 es igual a $t0
div $s1,$t0 Divide el valor que hay en $s1 con el valor en $t0
mfhi $s2 Mueve el registro hi hacia registro $s2
beq $s2,0,contador Salta si $s2 es igual a 0 y va a contador
addi $t0,$t0,1 Suma $t0 con 1
b loop Salto incondicional a loop
addi $t1,$t1,1 Suma inmediata de $t1 con 1
b go Salto incondicional a go
beq $t1,2,siesprimo Salte si $t1 es igual 2 a la etiqueta esprimo
li $t2,0 Carga $t2 con 0
b fin Salte a fin
li $t2,1 Carga $t2 con 1
fin: Etiqueta de Fin del programa
8. Definición de registros.
La mayoría de la arquitectura de computador emplean registro, moviendo datos desde la
memoria principal hacia los registros se opera sobre estos y el resultado es movido
nuevamente a la memoria principal.
Un registro es un bloque de memoria de alta velocidad y de poca capacidad el cual este
incorporado en el microprocesador que permita guardar transitoriamente y acceder a varios
valores muy usados generalmente en operaciones matemáticas.
TAMAÑO REGISTRO DESCRIPCION
• AX, AH, AL Registros de En arquitectura de ordenadores, un
(acumulador) Propósito registro es una memoria de alta
• BX, BH, BL (base) General velocidad y poca capacidad, integrada en
• CX, CH, CL el microprocesador.
(contador)
• DX, DH, DL (datos)
• SP (acumulador pila) Registros Estos registros son usados como índices
• BP (acumulador base) acumuladores por algunas instrucciones. También
• DI (índice destino) y de índice pueden ser usados como operandos
• SI (índice fuente) (excepto el registro IP)
• IP (apuntador de
instrucciones
• SC (codigo) Registros de Un registro de segmento tiene 16 bits de
• DS (datos) segmentos longitud y facilita un área de memoria
• ES (extra) para el direccionamiento conocida como
• SS (pila) el segmento actual
• Registro de Registros de Se utilizan para controlar las
direcciones de control operaciones del procesador, la mayor
memoria (MAR), parte de estos registros no son visibles al
• Registro de datos de usuario y algunos pueden ser accesibles
memoria (MBR) a las instrucciones de maquina
• Registro de ejecutadas en un modo de control.
direcciones de entrada
y salida (I/O AR)
• Registro de datos de
entrada y salida (I/O
BR)
• Registro de
instrucciones (IR)
• Palabras de estado del
programa (PSW)
9. Descripción modos de direccionamiento
Son distintas formas en las que se puede indicar la dirección efectiva de un operando
reciben el nombre de modos de direccionamiento. Los modos de direccionamiento que
referencian datos constantes o contenidos en registros son sencillos. Por otro lado, los que
se refieren a datos almacenados en memoria son muy variados y pueden ser de gran
complejidad. A continuación, se describen los modos de direccionamiento más comunes,
con las formas más habituales, si bien no únicas, de identificarlos
• Direccionamiento por registro: En el campo de dirección se especifica la dirección
del registro donde se encuentra el operando o donde hay que dejar el resultado.
Simbólicamente lo podemos representar de la siguiente manera:
• Direccionamiento inmediato: Se proporciona en el byte o bytes el operando que
siguen el código de operación de la instrucción. Este tipo de direccionamiento tiene
la ventaja de la rapidez ya que no se precisan referencias adicionales a la memoria
para extraer el operando. Sin embargo, presenta el inconveniente de ser una forma
poco flexible de localizar un operando.
• Direccionamiento directo: este direccionamiento solo se una en ordenadores
pequeños que el programa siempre se sitúa en la misma zona de memoria ya que la
dificultad la relocalización de los programas es decir el código de los programas no
dependan de su situación en memoria, En el campo de dirección se especifica la
dirección de memoria donde se encuentra el operando o donde hay que dejar el
resultado. Simbólicamente lo podemos representar de la siguiente manera:
[Link]ón del programa de alto nivel
# Politecnico Gran Colombiano
# Jessica Tatiana Zapata Chavarría
# Codigo para detectar si un numero es primo o no Arquitectura de Computadores
li $s1,5 # numero a testear si e sprimo o no
li $s2,0 # registro para sacar hi
li $t0,1 # variable incremental para el for
li $t1,0 # contador de módulos
li $t2,0 # registro si es primo es 1 sino es 0
add $s3,$s1,1 # numero a testear +1 para cumplir en el for
loop: beq $t0,$s3,esprimo # pregunta si t0 es igual al numero a testear +1 div
$s1,$t0 # divide el numero a testear en el valor actual de i "t0"
mfhi $s2 # mueve hi "modulo" hacia registro $s2
beq $s2,0,contador # si el modulo fue '0' salto a etiqueta contador
go: addi $t0,$t0,1 # suma 1 a i "t0" del for
b loop # salto incondicional a loop
contador: addi $t1,$t1,1 # aumento del contador de módulos
b go # Salto incondicional a go para aumentar i "t0"
esprimo: beq $t1,2,siesprimo # salte si el contador de móduloses 2 a "si"
li $t2,0 # como no es PRIMO cargo $t2 con '0' avisando al
usuario
b fin # salte a fin de programa
siesprimo: li $t2,1 # como SI es primo saco un 1al registro t2 para avisar
al usuario
fin: # fin del programa
En esta prueba se hizo con un 5 que es un numero primo, y en el registro $t2 queda en 1
indicando que es un numero primo
Acá la prueba con 8 que no es primo y en el registro $t2 al final muestra un 0 porque no es
primo
La prueba con 7 que, si es primo, y muestra en el registro $t2 un 1 porque si es primo
[Link]ón en HEXA
• 000040000 Cargar dato en un registro
• 001010000 Inicio ciclo
• 010040601 Validar valores entre registros 05 y 01
• 011040602 Dividir valores entre registros 05 y 01
• 1000406002 Adición valores entre registros 05 y 01
• 101000000 Fin Programa
[Link] en Logisim.
Paquete
ADDER
COMP1
COMP2
NOT
AND
NAND
OR
NOR
XOR
XNOR
ALU
ALU_FULL
En este archivo modificando el selector que está arriba, con las combinaciones que dice la
tabla de abajo hace la operación que ustedes quieran.
En este caso el SELECTOR está en 0000 entonces acorde a la tabla hace SUMA
A=1000 8
B=0010 2
SALIDA = 1010 es decir diez "10"
Y así se pueden probar las demás entradas u operaciones, dependiendo a la tabla
[Link]
La implementación de algoritmos en bajo nivel nos permite ver el comportamiento de los
registros en cuanto a cómo se cargan, y como se manipulan cada uno de ellos para realizar
una operación entre ellos, todo esto depende de la arquitectura del hardware que estemos
trabajando.
La generación de código en alto nivel permite manejar sentencias que nos facilitan
operaciones que en bajo nivel serian de gran complejidad como: división, modulo,
porcentaje e incluso el manejo de ciclos.
Analizando esta primera entrega de este trabajo se ha tocado un tema muy importante para
el entendimiento y compresión del desarrollo de los sistemas computacionales, determinar
si un número es primo o no es la rama de las matemáticas que trata propiedades aritméticas
de los números enteros.
[Link]ía
• Conjunto de instrucciones, (14 de septiembre) recuperado de:
[Link]
• Unidad Aritmético Lógica , (11 de septiembre) recuperado
de:[Link]
• Garcia, 2011 Universidad de México, recuperado de:
[Link]
[Link]
• Estructuras de control en JAVA, (10 de septiembre) recuperado de
[Link]
e&id=481:if-else-if-else-if-java-estructura-o-esquema-de-decision-condicional-
ejemplos-de-uso-ejercicios-cu00636b&catid=68&Itemid=188
