domingo, 19 de mayo de 2013

Memoria

En esta practica usaremos el programa logisim para el diseño de los ejercicios propuestos.
Para esta practicaes de gran utilidad tener conocimientos de la memoria RAM y de la ROM vistos en los temas de jerarquía de memoria, además de que en estos ejercicios se lleva a cabo la colocación de los módulos, algo muy importante.
 
Empecemos esta practica con un pequeño esquema del funcionamiento de una RAM en el simulador Logisim, sabiendo esto se podrá realizar la práctica sin mayores contratiempos, puesto que la ROM también usa un esquema similar en el simulador.
 En este caso he usado el montaje del ejercicio uno para señalar sus distintas partes y que sea sencillo su entendimiento
  • Bus de direcciones, indica la dirección de memoria a señalar, en este caso se trata de un bus de 16 bits
  • Selector de memoria, al activarlo se accede a la direccion de memoria indicada para su posterior lectura o escritura
  • Control de entrada/salida de la RAM, en función de su valor se indica si se va a escribir(0) o leer(1) el dato en la dirección de memoria indicada
  • Clear, reinicia todos los valores de la RAM, no es necesario usarlo en medio de una simulación, puesto que se pueden reescribir los datos, pero si se quiere reiniciar la simulación, es la mejor opción
  • Control de entrada, este interruptor nos es útil para controlar la entrada o no de los datos del bus de datos, en este montaje su valor debe ser el opuesto al control de entrada/salida de la RAM
  • Salida de datos, muestra los datos que salgan de la RAM o entren por el bus de datos
  • Bus de datos de 8 bits
 Ahora empecemos con la realización de los ejercicios propuestos, los hemos realizado en formato gif para facilitar la visión  en conjunto de lo que se está realizando, y por tanto, su comprensión. Para mejorar también la comprensión de la transformación de hexadecimal a binario, separaremos los dígitos binarios de 4 en 4, así cada bloque se correspondería con un dígito hexadecimal
 
1.- Introducir una memoria RAM de 64Kx8 y realizar un circuito que permita leer y escribir
en ella. Probar a introducir en las direcciones 0023h el dato 3A y en la dirección C120h el
dato 25.
Primero realizaremos la primera parte, introduciremos en 0x0023(0000 0000 0010 0011) el dato 3A(0011 1010)


Ahora introduciremos el dato 0x25(0010 0101) en la dirección 0xC120(1100 0001 0010 0000)

2.- Unir dos memorias del tipo utilizado en el apartado 1, para conformar una de 64Kx16.
Comprobar su funcionamiento de forma similar al apartado anterior: introduciendo algunos
datos de 16 bits en varias direcciones.
 
En este ejercicio emplearemos un bus de datos de 16 bits, puesto que el chip de RAM contiene 64K palabras de 8bits(64Kx8) necesitaremos un módulo de 2 chips para que se ajuste a la palabra del bus de datos
3.- Unir tres memorias para como las de los apartados anteriores (64Kx8) para conformar una
de 128Kx16. Comprobar su funcionamiento de forma similar al apartado anterior:
introduciendo algunos datos de 16 bits en varias direcciones.

En este ejercico implementamos un segundo módulo de RAM, por lo que ahora nuestro bus de direcciones se compondría de los 16 bits ya explicados y uno adicional(con mayor peso) que se correspondería al bit de selección

4.- Ampliar la memoria hasta 256Kx16 ¿Qué elemento será necesario para seleccionar cada
banco de dos memorias de 64Kx8? Un decodificador. Comprobar su funcionamiento de
forma similar al apartado anterior: introduciendo algunos datos de 16 bits en varias
direcciones.

En este ejercicio hemos aumentado aun mas el número de módulos de RAM, y 17 bits ya no son suficientes para direccionarlas, por lo que añadiremos un multiplexor para señalar el módulo de RAM, por lo que ahora poseeriamos 18 bits en el bus de datos(2 para indicar el módulo, 15 para la palabra y 1 para el Byte)
5.- Transformar la estructura del anterior punto para que los primeros 64K sean de memoria
ROM Observar que señales de control son las que intervienen en cada tipo de memoria.
Indica en cada bando el banco de direcciones de memoria que direcciona y obtén el mapa
de memoria del conjunto.

El montaje de este ejercicio es idéntico al anterior, pero sustituyendo el primer módulo de RAM por ROM, el funcionamiento es exactamente el mismo, salvo porque como ya sabemos en la ROM los datos no pueden ser escritos, solo leidos. Para editar los datos en el simulador usaremos el editor hexadecimal que incluye logisim

Bus de direcciones= 18 bits
Palabra= 16 bits= 2 Bytes
Módulo RAM=128KB
Rango de direcciones del módulo= 64K
Nº Módulos RAM= 3
Módulo ROM= 128KB
Nº Módulos ROM= 1

Si el bus de direcciones tiene 18 bits entonces el mapa de memoria tiene 218 direcciones pudiendose direccionar 218=256K palabras=64K * 4 módulos
Y como ya indicamos antes su distribución sería: 18 bits en el bus de datos(2 para indicar el módulo, 15 para la palabra y 1 para el Byte)
Y el mapa de memoria sería el siguiente
----------------------------------------------------------------------------------------------------------------------------
FAQ's

- ¿Qué es el editor hexadecimal de Logisim?
Logisim tiene un editor hexadecimal integrado para ver y alterar contenidos de memoria. Para
acceder a él, abre un menú desplegable para el componente de memoria correspondiente y
selecciona Editar Contenidos... Para componentes ROM, que presentan un atributo para los
contenidos de memoria, puedes acceder también al editor hexadecimal haciendo clic sobre el
atributo correspondiente. 

- ¿Porque se carga en la RAM el valor ff trás haber cargado un dato?
Esto ocurrirá sobre todo cuando actives el reloj automático del Logisim, tu velocidad administrando el circuito es muy inferior a la del ordenador, tras haber introducido el dato deberias haber cerrado la entrada de datos y encender el control de entrada/salida(que activaria la salida) de la RAM para que en el siguiente ciclo de reloj no se reescriba con el valor del bus, que al estar cortado no tendría valor, por lo tanto capta el valor ff
 
- ¿Diferencia entre capacidad total y palabras en un módulo?
La diferencia principal es debida a que la capacidad total se mide en multiplos de Bytes(8 bits) pero no siempre la palabra del bus de datos va a ser de 8, sino que puede ser de 16, 32, 64... En el ejemplo de la practica cada chip posee 64K palabras de 8 bits, o lo que es lo mismo, 64KB, por lo tanto el módulo tiene una capacidad total de 128KB, pero de 64K palabras de 16 bits
 
- ¿Porque los módulos son de dos chips?
Eso se debe a la diferencia entre la palabra del bus de datos y del chip, cada palabra del chip contiene 8 bits, en cambio el bus de datos lleva 16 bits, por lo tanto para no desperdiciar la capacidad del bus se utilizan dos chips conectados al mismo modulo, de manera que una dirección de ese módulo apunté a los dos chips, consiguiendose así los 16 bits que aprovecharían totalmente la capacidad del bus
 
- ¿Cómo podría realizar un montaje de autoinicialización de la RAM?
El montaje es bastante sencillo y la mecánica de dicho circuito se basa principalmente en la frecuencia del reloj y en los ticks en diferentes niveles. En este montaje por ejemplo, en el reloj de la RAM he dejado que cada nivel dure un tick, para la entrada A0 dos ticks, 4 para la A1, 8 para la A2 y 16 para la A3, resultando:
 


Los realizadores de la práctica son: Esperanza Cano, Miguel Angel González y Diego Fariñas

domingo, 12 de mayo de 2013

Unidad de Control

Esta practica está relacionada con el funcionamiento de la Unidad de Control (CU), cuya función es la de buscar las instrucciones en la memoria principal, decodificarlas y ejecutarlas.

PRÁCTICA 4

Sean las siguientes instrucciones:

a) ADD $t0, $t1, $t2
b) ADDI $s0,$s1, 0x0011
c) ORI $t0, $t2, 0x00A1
d) SLL $t0, $t0, 0x0002
e) SLR $t1, $t0, 0x0002
f) LUI $s0,0x0011
g) SW $t4, 0x0111
h) SLT $t1, $t2, $t0
i) J 0x000001A
j) JR $S0


1. Codificar las instrucciones en hexadecimal, tal como quedarían en memoria.

2. Utilizando la CPU descrita en clase teórica y el lenguaje de transferencia de registro, realizar la
secuencia de transferencias y acciones.

3. Comprobar que todo lo anterior se ha realizado de forma correcta mediante el simulador que se
adjunta para la práctica. Se introducirá el código de instrucción en la memoria de manera que
sean posible realizar todas las fases de la instrucción.


Para poder llevar a cabo la practica hay que tener claro lo que necesitamos:

Tabla de registros para poder codificar correctamente las instrucciones a hexadecimal:



Esquema de la CPU:


Esquema del simulador implementado en Logisim:



Códigos de operación de la ALU de las CPU anteriores:
  • 00001 Suma
  • 00010 Resta
  • 00011 OR
  • 00100 AND
  • 00101 Desplazamiento a la derecha de 1,2,3,4 bits
  • 00110 Desplazamiento a la izquierda de 1,2,3,4 bits
  • 00111 NOT
  • 01000 XOR

------------------------------------------------------------------------------------------------------------

a) ADD $t0, $t1, $t2



000000|01001|01010|01000|00000|100000

0000|0001|0010|1010|0100|0000|0010|0000 (Agrupamos de 4 en 4 para pasarlo a hexadecimal)

0x012A4020


Lenguaje de transferencia                                Señales                                                               
C1
MAR  PC
T4, C1
C2PC  PC + 4
MBR  MP(MAR)
Td, L, C2, C4
C3RI  MBRT3, C6
C4Decodificación
C5R8  R9 + R10 
RA=1001, RB=1010, MA=0, MB=0, 
C.Op=00001, T5, RC=1000, SC
C6Comprobación de las señales de interrupción

------------------------------------------------------------------------------------------------------------

b) ADDI $s0,$s1, 0x0011





001000|10001|10000|0000000000010001

0010|0010|0011|0000|0000|0000|0001|0001 (Agrupamos de 4 en 4 para pasarlo a hexadecimal)

0x22300011

Lenguaje de transferencia                                Señales                                                       
C1MAR  PCT4, C1
C2PC  PC + 4
MBR  MP(MAR)
Td, L, C2, C4
C3RI  MBRT3C6
C4Decodificación
C5RT2 ← RIT8, C10
C6R16  R17 + RT2
RA=10001, MA=0, MB=1, C.Op=00001,
T5, RC=10000, SC

C7Comprobación de las señales de interrupción

------------------------------------------------------------------------------------------------------------

c) ORI $t0, $t2, 0x00A1



001101|01010|01000|0000000010100001

0011|0101|0100|1000|0000|0000|1010|0001 (Agrupamos de 4 en 4 para pasarlo a hexadecimal)

0x354800A1


Lenguaje de transferencia                                Señales                                                               
C1MAR  PCT4, C1
C2PC  PC + 4
MBR  MP(MAR)
Td, L, C2, C4
C3RI  MBRT3C6
C4Decodificación
C5RT2  RIT8, C10
C6R8 ← R10 or RT2
RA=1010, MA=0, MB=1, C.Op=00011, T5,
RC=1000, SC

C7Comprobación de las señales de interrupción

------------------------------------------------------------------------------------------------------------

d) SLL $t0, $t0, 0x0002



Esta instrucción con valor inmediato es tiene la siguiente peculiaridad:

"Shift register rt left (right) by the distance indicated by immediate shamt or
the register rs and put the result in register rd. Note that argument rs is ignored
for sll, sra, and srl."

000000|00000|01000|01000|00010|000000

0000|0000|0000|1000|0100|0000|1000|0000 (Agrupamos de 4 en 4 para pasarlo a hexadecimal)

0x00084080


Lenguaje de transferencia                                Señales                                                               
C1MAR  PCT4, C1
C2PC  PC + 4
MBR  MP(MAR)
Td, L, C2, C4
C3RI  MBRT3C6
C4Decodificación
C5RT2  RI T8, C10
C6R8  R8 + RT2RA=1000, MA=0, MB=1, C.Op=00110, T5,
RC=1000, SC
C7Comprobación de las señales de interrupción

------------------------------------------------------------------------------------------------------------

e) SRL $t1, $t0, 0x0002



Esta instrucción con valor inmediato es tiene la siguiente peculiaridad:

"Shift register rt left (right) by the distance indicated by immediate shamt or
the register rs and put the result in register rd. Note that argument rs is ignored
for sll, sra, and srl."

000000|00000|01000|01001|00010|000010

0000|0000|0000|1000|0100|1000|1000|0010 (Agrupamos de 4 en 4 para pasarlo a hexadecimal)

0x00088882



Lenguaje de transferencia                                Señales                                                               
C1MAR  PCT4, C1
C2PC  PC + 4
MBR  MP(MAR)
Td, L, C2, C4
C3RI  MBRT3C6
C4Decodificación
C5RT2  RI T8, C10
C6R9  R8 + RT2RA=1000, MA=0, MB=1, C.Op=00101, T5,
RC=1001, SC
C7Comprobación de las señales de interrupción

------------------------------------------------------------------------------------------------------------

f) LUI $s0,0x0011






001111|00000|10000|0000000000010001

0011|1100|0001|0000|0000|0000|0001|0001 (Agrupamos de 4 en 4 para pasarlo a hexadecimal)

0x3C100011


Lenguaje de transferencia                                Señales                                                               
C1MAR  PCT4, C1
C2PC  PC + 4
MBR  MP(MAR)
Td, L, C2, C4
C3RI  MBRT3C6
C4Decodificación
C5MAR  RI (17-32)T8, C1
C6MBR  MP(MAR)TD, L, C2
C7R16 ← MBRT3, RC=10000, SC
C8Comprobación de las señales de interrupción

------------------------------------------------------------------------------------------------------------

g) SW $t4, 0x0111







101011|00000|01100|0000000100010001

1010|1100|0000|1100|0000|0001|0001|0001 (Agrupamos de 4 en 4 para pasarlo a hexadecimal)

0xAC0C0111


Lenguaje de transferencia                                Señales                                                               
C1MAR  PCT4, C1
C2PC  PC + 4
MBR  MP(MAR)
Td, L, C2, C4
C3RI  MBRT3C6
C4Decodificación
C5MBR  R12RA=1100, T1, C3
C6MAR  RIT8, C1
C7MP ← MBRTA, TD, E
C8Comprobación de las señales de interrupción

------------------------------------------------------------------------------------------------------------

h) SLT $t1, $t2, $t0








000000|01010|01000|01001|00000|101010

0000|0001|0100|1000|0100|1000|0010|1010 (Agrupamos de 4 en 4 para pasarlo a hexadecimal)

0x0148482A



Lenguaje de transferencia                                Señales                                                               
C1MAR  PCT4, C1
C2PC  PC + 4
MBR  MP(MAR)
Td, L, C2, C4
C3RI  MBRT3C6
C4Decodificación
C5R9 = R10<R8RA=1010, RB=1000, MA=0, MB=0,
C.Op=00110, T5, RC=1001, SC
C6Comprobación de las señales de interrupción
------------------------------------------------------------------------------------------------------------

i) J 0x000001A







000010|00000000000000000000011010

0000|1000|0000|0000|0000|0000|0001|1010 (Agrupamos de 4 en 4 para pasarlo a hexadecimal)

0x0800001A



Lenguaje de transferencia                                Señales                                                               
C1MAR  PCT4, C1
C2PC  PC + 4
MBR  MP(MAR)
Td, L, C2, C4
C3RI  MBRT3C6
C4Decodificación
C5PC  RIT8, C5
C6Comprobación de las señales de interrupción
------------------------------------------------------------------------------------------------------------

j) JR $S0







000000|10000|000000000000000|001000

0000|0010|0000|0000|0000|0000|0000|1000 (Agrupamos de 4 en 4 para pasarlo a hexadecimal)

0x02000008



Lenguaje de transferencia                                Señales                                                               
C1MAR  PCT4, C1
C2PC  PC + 4
MBR  MP(MAR)
Td, L, C2, C4
C3RI  MBRT3C6
C4Decodificación
C5PC  R16RA=10000, T1, C5
C6Comprobación de las señales de interrupción
------------------------------------------------------------------------------------------------------------


FAQ's

- ¿Donde puedo encontrar el formato de las instrucciones para poder codificarlas?
Esta parte de la practica corresponde al tema 2, en los apuntes del campus virtual correspondiente a este  tema, podemos encontrar el formato y ejemplos de como realizar la codificación.  

- En el banco de registros hay un error en los buses. ¿Cómo lo puedo solucionar?
Esto puede deberse a que el decodificador que va unido a los triestados tiene en el atributo "Disabled output" seleccionado "floating". Esto hará que si el decodificador no está activado, el valor de salida sea indefinido. Debemos cambiarlo a "zero" para que al estar desactivado, el valor de salida sea 0, y así los triestados funcionarán.

- ¿Qué debo hacer para empezar de nuevo la simulación de un circuito en Logisim?
Debes pulsar crtl y la tecla R, o darle al botón simulación y "Reset simulation"


- ¿Qué debo hacer para poder mostrar una imagen de mi circuito?
Debes pulsar en "Archivo" y luego en "Export image", de la siguiente forma.


- ¿Por que en los 4 primeros ciclos de reloj siempre se repiten los mismos pasos independientemente de la instrucción?
Porque se ha de generar una secuencia de señales de control que posibiliten buscar el código de instrucción en memoria, su carga en RI y la preparación de PC para el ciclo de instrucción siguiente. y posteriormente su decodificación localizando la secuencia de señales de control que den lugar a la ejecución de la instrucción.