1
Entrega
Karen Andrea Portillo Saavedra
Institución Universitaria Politécnico Grancolombiano
Arquitectura del Computador
Alexandra María Silva Monsalve
15 de noviembre de 2024
2
TABLA DE CONTENIDO
Entrega Previa 1- Semana 3 ................................................................................................................3
Selección del problema de Fibonacci .................................................................................................3
Realización del algoritmo....................................................................................................................4
Instrucciones requeridas para la solución............................................................................................5,6
Entrega previa 2- Semana 5.................................................................................................................7
1. Listado de instrucciones con detalle .................................................................................................7
a. Nombre, neumónico, parámetros que recibe............................................................................8,9
2. Tamaño de registros..........................................................................................................................10
3. Descripción de los modos de direccionamiento................................................................................11
4. Traducción del Programa a Ensamblador.............................................................................12, 13, 14
5. Listado HEXA..................................................................................................................................15
Entrega previa 3- Semana 7...............................................................................................................16
a. Memoria de Programa, ALU, Registros, Unidad de Control, etc....................................................16
b. Documento de diseño, etc............................................................................................................17,18
c. Documento de conclusiones, etc.......................................................................................................19
Referencias.............................................................................................................................................20
3
Entrega Previa 1 - Semana 3
Selección del Problema Fibonacci
La secuencia de Fibonacci es una serie de números en la que cada número es la suma de los dos
anteriores, comenzando generalmente con 0 y 1. La sucesión se expresa matemáticamente como:
• F(0) = 0
• F(1) = 1
• F(n) = F(n − 1) + F(n − 2) para n >= 2
Por ejemplo, la secuencia empieza así: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, y así sucesivamente. Esta
secuencia ha sido estudiada desde tiempos antiguos debido a su relación con patrones en la naturaleza y
las matemáticas.
Realización del Algoritmo
4
Instrucciones Requeridas para la Solución
Los pasos por seguir en el problema 2 de Fibonacci son:
• Dato de entrada: Se pide ingresar al usuario el valor de n que es el número por el cual se desea
calcular, este será cuántos números de sucesión se van a generar.
• Verificación que no sea un número válido: Se valida que no sea mayor que 0, ya que no se
puede generar cantidad negativa o nula de los números. Si el valor de n es menor o igual a 0, se
muestra al usuario un mensaje de error.
• Inicialización de variables a y b: Se inicializa a y b con las dos primeras variables de sucesión
de Fibonacci, donde a es igual 0 y b es igual a 1, estas representan los dos primeros números de la
sucesión
5
• Flujo: Se crea un flujo como (For) para que repita la operación de suma de los últimos números
hasta calcular n números de acuerdo con el número que se ingresó inicialmente. En cada
repetición suma los dos números anteriores para obtener el siguiente.
• Mostrar los resultados: En cada iteración se imprime o muestra el valor que vendría siendo el
valor actual en fibonacci.
• Por ejemplo, si el valor ingresado es 7, el algoritmo que mostrará será: 0,1,1,2,3,5,8
(Bravo, s.f.) (Universidad de Almería, s.f.)
6
Entrega Previa 2 - Semana 5
Listado de Instrucciones con Detalle
Instrucciones comunes y su detalle:
Instrucción Nemónico Parámetros Descripción
mov MOV destino, Copia el valor de fuente a destino.
fuente
int INT numero Ejecuta una interrupción para llamar funciones del
sistema, como escribir en la pantalla o leer de la
entrada.
add ADD registro, Suma valor al contenido de registro y almacena el
valor resultado en registro.
cmp CMP registro, Compara el contenido de registro con valor,
valor estableciendo las banderas adecuadas.
jne JNE etiqueta Salta a la etiqueta si la comparación previa (con
CMP) no resultó en igualdad.
jmp JMP etiqueta Salta incondicionalmente a la etiqueta indicada.
push PUSH registro Coloca el valor de registro en la pila.
pop POP registro Extrae el valor de la cima de la pila y lo coloca en
registro.
Cada instrucción recibe parámetros específicos, por ejemplo, mov eax, 1 asigna el valor 1 al registro eax.
7
Nombre, Nemónico, Parámetros que recibe.
Nombre: Secuencia de Fibonacci
Nemónico: fib o fibonacci
Parámetros o variables involucradas:
1. n: El número de términos de la secuencia que deseas calcular.
2. a: El primer término de la secuencia (generalmente 0).
3. b: El segundo término de la secuencia (generalmente 1).
La secuencia de Fibonacci se define de la siguiente manera:
• F(0) = 0
• F(1) = 1
• F(n) = F(n-1) + F(n-2) para n ≥ 2
La función de Fibonacci recibe un número entero ( n ) como parámetro y devuelve el ( n )-ésimo término
de la secuencia de Fibonacci. La secuencia comienza con 0 y 1, y cada término subsiguiente es la suma de
los dos términos anteriores
a. Descripción de una frase indicando qué hace en términos de lo que recibe como parámetro.
Sección .data:
• msg_input: Este es un mensaje que se mostrará al usuario para solicitarle que ingrese
el número de términos de la sucesión de Fibonacci que desea calcular.
• err_fib: Este mensaje se mostrará si el usuario ingresa un número menor o igual a 0.
• num: Aquí se almacenará el número ingresado por el usuario.
Sección .bss:
• a: Se utilizará para almacenar el primer término de la sucesión (0).
• b: Se utilizará para almacenar el segundo término de la sucesión (1).
• temp: Se utilizará como variable temporal para realizar cálculos.
Sección .text:
8
• start: Este es el punto de entrada del programa.
• mostrar_mensaje: Esta parte del código se encarga de imprimir en pantalla el
mensaje msg_input para solicitar la entrada del usuario.
• leer_entrada: Aquí se lee el número ingresado por el usuario y se almacena en la
variable num.
• inicializar: Se inicializan las variables a y b con los valores iniciales de la sucesión de
Fibonacci (0 y 1).
• bucle: Este es el corazón del algoritmo. Se utiliza un bucle para calcular los num
primeros términos de la sucesión. En cada iteración, se calcula el siguiente término
sumando los dos anteriores y se desplazan los valores de a y b para preparar la
siguiente iteración.
En resumen:
1. Entrada: El programa solicita al usuario que ingrese un número entero positivo. Este
número representa la cantidad de términos de la sucesión de Fibonacci que se desea
calcular.
2. Inicialización: Se inicializan las variables a y b con los valores iniciales de la
sucesión (0 y 1).
3. Cálculo: Se utiliza un bucle para calcular los términos de la sucesión de Fibonacci de
forma iterativa. En cada iteración, se calcula el siguiente término sumando los dos
anteriores.
4. Salida: Los términos calculados se pueden imprimir en pantalla o almacenar en una
estructura de datos para su posterior procesamiento.
9
Tamaño de los registros:
Todos los registros mencionados son de 32 bits, lo que significa que pueden almacenar enteros de hasta 4
bytes.
Registros utilizados:
• eax: Utilizado para almacenar temporalmente el valor de Fibonacci en cada iteración.
Tamaño: 32 bits (4 bytes).
• ecx: Almacena el valor F(n-2) en cada paso de la iteración. Tamaño: 32 bits (4 bytes).
• edx: Almacena el valor F(n-1) en cada paso de la iteración. Tamaño: 32 bits (4 bytes).
• ebx: Utilizado como contador para llevar la cuenta del número de iteraciones
restantes. Tamaño: 32 bits (4 bytes).
• Total de registros: 4 registros, cada uno de 32 bits.
10
Descripción de los Modos de Direccionamiento
Modos de direccionamiento posibles:
• Inmediato: Se refiere a un valor constante, por ejemplo, mov eax, 1.
• Directo: Accede directamente a una dirección de memoria, como mov eax, [variable].
• Indirecto: Utiliza un registro como puntero a la memoria, por ejemplo, mov eax, [ebx].
• Indexado: Usa un registro con un desplazamiento, como mov eax, [ebx + 4].
Traducción del Programa a Ensamblador.
11
12
13
14
Listado HEXA del binario que representa el programa realizado en el punto 4 de esta entrega.
15
Entrega previa 3- Semana 7
1. Archivo .circ, realizado sobre Logisim, que incluye: a. Memoria de Programa, ALU, Registros, Unidad
de Control, interconectados de tal forma que sea capaces de ejecutar el programa diseñado.
16
b. Documento de diseño, reuniendo las entregas 1 y 2, así como la documentación del diseño de la
microarquitectura (Memoria de Programa, ALU, Registros, Unidad de Control)
Diseño de Microarquitectura
Memoria de Programa
La Memoria de Programa almacena las instrucciones en ensamblador convertidas a formato hexadecimal.
Estas instrucciones son ejecutadas por la Unidad de Control, coordinando las operaciones en el
procesador.
Unidad Aritmeticológica (ALU)
La ALU es capaz de realizar operaciones básicas como suma, multiplicación, comparaciones y cálculo de
residuos. Estas operaciones son esenciales para determinar si un número es primo.
Registros
El procesador utiliza 15 registros de 8 bits para almacenar datos intermedios, instrucciones y resultados.
Los registros incluyen el Registro de Instrucción (IR), el Contador de Programa (PC), el Registro de
Dirección de Memoria (MAR) y el Registro Intermedio de Memoria (MBR).
Unidad de Control
La Unidad de Control interpreta las instrucciones almacenadas en la Memoria de Programa y coordina las
operaciones de los diferentes módulos. Implementa señales de control para la ALU, los registros y el flujo
de datos.
17
Interconexión de Componentes
Los módulos del procesador están interconectados a través de buses de datos y señales de control. La
Memoria de Programa se comunica con la Unidad de Control para cargar instrucciones, mientras que la
ALU opera directamente sobre los datos almacenados en los registros.
Memoria del
programa
Unidad de control
ALU
Registros
Este diagrama muestra la interconexión básica entre los componentes principales de tu procesador: la
Memoria de Programa, la Unidad de Control, la ALU y los Registros.
18
c. Documento de conclusiones, donde se presenten los ejemplos probados, los resultados obtenidos y las
conclusiones críticas del proyecto desarrollado.
• Ejemplos Probados
Se realizaron pruebas con diferentes números para verificar la funcionalidad del procesador. Los
resultados fueron los siguientes:
- Número 3: Resultado 'Es Primo'.
- Número 6: Resultado 'No Es Primo'.
Estas pruebas confirmaron que el procesador realiza las operaciones correctamente.
• Resultados Obtenidos
El circuito diseñado cumplió con los objetivos propuestos. Las pruebas demostraron que las instrucciones
en ensamblador fueron ejecutadas correctamente, y los resultados mostraron precisión en la detección de
números primos.
• Análisis Crítico
El proyecto permitió profundizar en el diseño de microarquitecturas y en el manejo de simuladores como
Logisim. Aunque se logró una implementación funcional, se identificaron algunas áreas de mejora, como
la optimización de la Unidad de Control y la reducción del tamaño de los registros sin comprometer el
rendimiento.
• Conclusión
El desarrollo de este procesador básico sirvió como una herramienta pedagógica para entender los
principios fundamentales de la arquitectura de computadores. Además, el uso de herramientas digitales
resultó en un producto funcional y educativo, se obtuvieron conocimientos en el proceso que es lo más
importante.
19
Referencias
Bravo, R. (s.f.). La sucesión de Fibonacci en el diseño. EADE. Recuperado de
[Link]
Universidad de Almería. (s.f.). Sucesión de Fibonacci. Jardín de los matemáticos. Recuperado de
[Link]
Información basada en el manual de Logisim. (s.f.). Logisim Documentation. Recuperado de
[Link]
Microsoft. (s.f.). Conocimientos de arquitectura de computadores y diseño de
microarquitectura en Logisim. Copilot Cloud. Recuperado de
[Link]
2F4AFA&auth=2
