1

ENTREGA PREVIA 1

Universidad Politecnico Gran Colombiano.

Facultad de Ingeniería.
Arquitectura del Computador.

Heyden Moreno Angel

2022.
 2

Introducción

Para lograr que las máquinas hagan lo que queremos debemos dar las instrucciones necesarias

mediante algoritmos y lenguajes de programación tales como Java, C++, Python estos lenguajes

son traducidos a un lenguaje de máquina compuesto únicamente por 1 y 0.

Objetivo General

Plantear y diseñar el conjunto de instrucciones y la microarquitectura de un procesador

usando un lenguaje de alto nivel Pseint que nos ayuda a diagramar el algoritmo e identificar las

instrucciones requeridas para que el procesador realice el cálculo de si un input de un número es

primo o no.

Desarrollo

La arquitectura del conjunto de instrucciones (ISA) se emplea a veces para distinguir este

conjunto de características de la microarquitectura, que son los elementos y técnicas que

Se emplean para implementar el conjunto de instrucciones. Entre estos elementos se

encuentran las microinstrucciones y los sistemas de caché.

Procesadores con diferentes diseños internos pueden compartir un conjunto de

instrucciones; por ejemplo, el Intel Pentium y AMD Athlon implementan versiones casi

idénticas al conjunto de instrucciones x86, aunque tienen diseños diferentes. (Wikipedia,

2020)
 3

Descripción del algoritmo en pseudocódigo para determinar si un número es primo o no

Programa PSelnt.

Algoritmo arq_computadores

definir x,num,contador Como Entero

Escribir "Ingrese el numero"

leer num

x=1

contador = 0

mientras x < num hacer

si num mod x == 0 Entonces

contador = contador + 1

FinSi

x=x+1

FinMientras

si contador == 2 Entonces

Escribir "El numnero",num," es primo"

SiNo

Escribir "El numnero",num," no es primo"

FinSi

FinProceso
 4

Codigo en java
 5

Definición de la cantidad de registros que se usarán y el tamaño de cada registro.

Los registros de memoria son una pequeña cantidad de memoria muy rápida en donde

almacena y accede a datos de mayor frecuencia lo que permite incrementar la velocidad del

programa en ejecución. La mayoría de las arquitecturas de computadora emplean registros,

moviendo datos desde la memoria principal hacia los registros, se opera sobre éstos, y el

resultado es movido nuevamente a la memoria principal.

 6

Registro Descripción
Registro acumulador,usandolo se
produce una instrucción que ocupa un
V
byte menos que si se utilizaran otros
registros de uso general
Registro de uso general,debe utilizarse
solo como puntero de pila, la cual sirve
SP para almacenar las direcciones de
retorno de subrutinas y datos
temporarios.
Registro base de propósito similar (se
BX
usa para direccionamiento indirecto)
Registro contador, se utiliza como
CX contador en bucle, en operaciones con
cadenas
Registro de datos, se utiliza junto con
el
registro AX en multiplicaciones y
DX
divisiones en la instrucción CWD(el
registro DX indica el número de puerto
de entrada/salida)
Puntero base, generalmente se utiliza
BP para realizar direccionamiento indirecto
dentro de la pila
Puntero destino(no se puede
DI
subdividir)
Puntero índice, sirve como puntero
fuente para las operaciones con
SI
cadenas, también sirve para realizar
direccionamiento indirecto

Descripción breve de los modos de direccionamiento que serán posibles.

Es el conjunto de reglas que especifican una localización (posición) del dato usado durante

la ejecución de una instrucción. El microprocesador desempeña una función con facilidad

 7

debido a que usa un modo de direccionamiento el cual especifica la forma en que se interpreta

la información.

El registro definido por la instrucción que contiene el operando.

Se proporciona en el byte o bytes el operando que siguen el código de operación de la

instrucción.
 8

El byte o par de bytes que siguen al código OP de la instrucción da el desplazamiento de 8 ó

16 bits, que, sumado al contenido del registro DS, determina la dirección efectiva en la que se

encuentra el dato a transferir.

Traducción del programa de alto nivel (entrega 1) al lenguaje ensamblador que han

construido, usando su propio conjunto de instrucciones.

file "primo.c"
.intel_syntax noprefix
.text
.def ___main; .scl 2; .type 32; .endef
.section .rdata,"dr"
LC0:
.ascii "\12Numero.....: \0"
LC1:
.ascii " %d\0"
LC2:
.ascii "\12El numero %d es primo\0"
 9

LC3:
.ascii "\12El numero %d no es primo\0"
.text
.globl _main
.def _main; .scl 2; .type 32; .endef
_main:
LFB17:
.cfi_startproc
push ebp
.cfi_def_cfa_offset 8
.cfi_offset 5, -8
mov ebp, esp
.cfi_def_cfa_register 5
and esp, -16
sub esp, 32
call ___main
mov DWORD PTR [esp+20], 0
mov DWORD PTR [esp+28], 0
mov DWORD PTR [esp+24], 0
L8:
mov DWORD PTR [esp], OFFSET FLAT:LC0
call _printf
lea eax, [esp+20]
mov DWORD PTR [esp+4], eax
mov DWORD PTR [esp], OFFSET FLAT:LC1
call _scanf
mov eax, DWORD PTR [esp+20]
cmp eax, -1
je L2
mov eax, DWORD PTR [esp+20]
test eax, eax
jle L2
mov DWORD PTR [esp+24], 0
mov DWORD PTR [esp+28], 2
jmp L3
L6:
mov eax, DWORD PTR [esp+20]
cdq
idiv DWORD PTR [esp+28]
mov eax, edx
test eax, eax
jne L4
mov DWORD PTR [esp+24], 1
L4:
add DWORD PTR [esp+28], 1
 10

L3:
mov eax, DWORD PTR [esp+20]
cmp DWORD PTR [esp+28], eax
jge L5
cmp DWORD PTR [esp+24], 1
jne L6
L5:
cmp DWORD PTR [esp+24], 0
jne L7
mov eax, DWORD PTR [esp+20]
mov DWORD PTR [esp+4], eax
mov DWORD PTR [esp], OFFSET FLAT:LC2
call _printf
jmp L2
L7:
mov eax, DWORD PTR [esp+20]
mov DWORD PTR [esp+4], eax
mov DWORD PTR [esp], OFFSET FLAT:LC3
call _printf
L2:
mov eax, DWORD PTR [esp+20]
cmp eax, -1
jne L8
mov eax, 0
leave
.cfi_restore 5
.cfi_def_cfa 4, 4
ret
.cfi_endproc
LFE17:
.ident "GCC: (MinGW.org GCC-8.2.0- 3) 8.2.0"
.def _printf; .scl 2; .type 32; .endef
.def _scanf; .scl 2; .type 32; .endef
 11

Listado en HEXA del binario que representa el programa realizado en el punto 4 de esta

entrega.

BINARIO HEXADECIMAL
10110100 B4
1 1
11001101 CD
100001 21
10001010 8A
11111000 F8
11011000 D8
 12

10 2
11011111 DF
1110101 75
11 3
11101001 E9
11100011 E3
0 0
10111011 BB
10111000 B8
110 6
10110111 B7
111 7
10111010 BA
10111001 B9
1001111 4F
11000 18
1010111 57
10000 10
10110110 B6
10111010 BA
101 5
11101000 E8
11111101 FD
1111100 7C
11000111 C7
11111001 F9
111001 39
1111111 7F
11000010 C2
10000000 80
11111011 FB
10011100 9C
1110100 74
1000 8
 13

10011101 9D
10001000 88
101110 2E
1010101 55
1110 0E
1010110 56
110000 30
10110000 B0
1010 0A
10001001 89
10110101 B5
1110100 74
11110 1E
111011 3B
11101011 EB
11101010 EA
11110111 F7
11110011 F3
1110100 74

ALU en Logisim, que pueda ejecutar las instrucciones requeridas por el programa.

Son dos entradas de datos de 4 bits que son los números para operar, los cuales

aparecen como valor1 y valor2 y el resultado es de 5 Bits una salida de 1 bit para la

referencia del residuo.

 14

Conclusiones

Con el avance de nuestro proyecto hemos logrado especificar las sentencias necesarias en

lenguaje Java para poder determinar si un número es primo o no. También hemos identificado las

instrucciones que necesitaremos para poder implementar estas instrucciones que necesitaremos

para poder implementar este algoritmo en lenguaje MIPS.