Simulación de CPU
Este proyecto simula un sistema informático simple que consiste en una CPU y una memoria. La CPU y la memoria están simuladas por procesos separados que se comunican. La memoria contiene un programa que la CPU ejecutará y luego la simulación finalizará.
Para CPU:
- Tendrá estos registros: PC, SP, IR, AC, X, Y.
- Admitirá las instrucciones que se muestran a continuación.
- Ejecutará el programa de usuario en la dirección 0.
- Las instrucciones se obtienen en el IR de memoria. El operando se puede obtener en una variable local.
- Cada instrucción debe ejecutarse antes de obtener la siguiente instrucción.
- La pila de usuarios reside al final de la memoria del usuario y crece hacia la dirección 0.
- La pila del sistema reside al final de la memoria del sistema y crece hacia abajo hacia la dirección 0.
- No hay aplicación de hardware del tamaño de la pila.
- El programa finaliza cuando se ejecuta la instrucción final. Los 2 procesos deben terminar en ese momento.
- El programa de usuario no puede acceder a la memoria del sistema (salga con el mensaje de error).
Para la memoria:
- Consistirá en 2000 entradas enteras, 0-999 para el programa de usuario, 1000-1999 para el código del sistema.
- Admitirá dos operaciones: Read (dirección): devuelve el valor en la dirección; escribir (dirección, datos): escribe los datos en la dirección
- La memoria se inicializará leyendo un archivo de programa.
Para el temporizador:
- Un temporizador interrumpirá el procesador después de cada x instrucciones, donde X es un parámetro de línea de comandos.
Para el procesamiento de la interrupción:
- Hay dos formas de interrupciones: el temporizador y una llamada del sistema utilizando la instrucción INT.
- En ambos casos, la CPU debe ingresar al modo Kernel.
- El puntero de la pila debe cambiarse a la pila del sistema.
- Los registros SP y PC deben guardar en la pila del sistema. (El controlador puede ahorrar registros adicionales).
- Una interrupción del temporizador debe causar la ejecución en la dirección 1000.
- La instrucción INT debe causar la ejecución en la dirección 1500.
- Las interrupciones deben deshabilitarse durante el procesamiento de interrupciones para evitar la ejecución anidada.
- La instrucción IRET regresa de una interrupción.
Conjunto de instrucciones:
-> 1 = Valor de carga # Cargar el valor en el CA
-> 2 = cargar addr # Cargue el valor en la dirección en el CA
-> 3 = Loadind ADDR # Cargue el valor de la dirección encontrada en la dirección dada en el AC. (Por ejemplo, si loadind 500 y 500 contiene 100, luego cargue de 100).
-> 4 = LoadIdxx Addr # Cargue el valor en (dirección+x) en el AC. (Por ejemplo, si LoadIdxx 500 y X contienen 10, luego se carga de 510).
-> 5 = loadidxy addr # Cargue el valor en (dirección+y) en el aire acondicionado
-> 6 = LoadSpx # Cargar de (SP+X) en el AC (si SP es 990, y x es 1, carga desde 991).
-> 7 = Almacene ADDR # almacene el valor en el CA en la dirección
-> 8 = Get # Obtiene un INT aleatorio de 1 a 100 en el AC
-> 9 = Pon Port # if Port = 1, escribe AC como un int en la pantalla; Si Port = 2, escribe AC como un char a la pantalla
-> 10 = addx # Agregue el valor en x al aire acondicionado
-> 11 = addy # Agregue el valor en y al aire acondicionado
-> 12 = Subx # Resta el valor en x del AC
-> 13 = Suby # Resta el valor en y del AC
-> 14 = Copytox # Copie el valor en el CA a X
-> 15 = copyFromx # Copie el valor en x al aire acondicionado
-> 16 = Copytoy # Copie el valor en el AC a Y
-> 17 = Copyfromy # Copie el valor en y al aire acondicionado
-> 18 = Copytosp # Copie el valor en AC al SP
-> 19 = copyFromSp # Copie el valor en SP al AC
-> 20 = Jump Addr # Jump a la dirección
-> 21 = Jumpifequal add # salta a la dirección solo si el valor en el aire acondicionado es cero
-> 22 = Jumpifnotequal add # salta a la dirección solo si el valor en el aire acondicionado no es cero
-> 23 = Llame a Addr # Puse la dirección de retorno a la pila, salte a la dirección
-> 24 = RET # Dirección de retorno Pop desde la pila, salte a la dirección
-> 25 = Incx # Incrementa el valor en x
-> 26 = decx # disminución el valor en x
-> 27 = empuje # empuje AC en la pila
-> 28 = Pop # Pop desde la pila en AC
-> 29 = int # realizar una llamada al sistema
-> 30 = Iret # Regreso de la llamada del sistema
-> 50 = END # Ejecución final
================================================================================================================================
La carpeta de muestra contiene 5 archivo de muestra.
muestra1.txt
- Prueba las instrucciones de carga indexadas.
- Imprime dos tablas, una de AZ, la otra de 1-10.
muestra2.txt
- Prueba las instrucciones de llamada/ret.
- Imprime una cara donde se imprimen las líneas con llamadas de subrutina.
muestra3.txt
- Prueba las instrucciones int/iret.
- El bucle principal es imprimir la letra A seguido de un número que el temporizador está incrementando periódicamente.
- El número se incrementará más rápido si el período del temporizador es más corto.
muestra4.txt
- Prueba el funcionamiento adecuado de la pila de usuarios y la pila del sistema, y también prueba que acceder a la memoria del sistema en modo de usuario proporciona un error y sale.
muestra 5.txt
- Este es uno que debes crear. Asegúrese de incluir comentarios para que el calificador sepa lo que está haciendo el programa.
================================================================================================================================
Paso para compilar y ejecutar el proyecto:
- S1: Copie los archivos de origen en el sistema Linux.
- S2: cambie el directo a los archivos de origen
- S3: Ejecute el siguiente comando: gcc memory.c cpu.c simulator.c
- S4: Ejecute el programa: ./a.out
- S5: De acuerdo con la información de salida, ingrese el parámetro del temporizador X, nombre de archivo que desea ejecutar respectivamente. Cada elemento termina con "Enter". por ejemplo: 10 ( n) muestra2.txt
- S6: Repita S4 para los archivos de prueba de muestra restantes para obtener las diversas salidas
