MEZCLA - MIX

MEZCLA
Diseñador Donald Knuth
Bits 31 bits
Introducido 1968
Diseño máquina acumuladora
Escribe hipotético
Codificación Reparado
Derivación Código de condición y prueba de registro
Endianidad Grande
Abierto Sí, y libre de regalías
Registros
9 en total

MIX es una computadora hipotética utilizada en la monografía de Donald Knuth , The Art of Computer Programming ( TAOCP ). El número de modelo de MIX es 1009, que se derivó de la combinación de los números de modelo y los nombres de varias máquinas comerciales contemporáneas consideradas significativas por el autor. Además, "MIX" leído como un número romano es 1009.

Desde entonces, el MIX de la década de 1960 ha sido reemplazado por una nueva arquitectura de computadora (también hipotética), MMIX , que se incorporará en las próximas ediciones de TAOCP .

Las implementaciones de software para las arquitecturas MIX y MMIX han sido desarrolladas por Knuth y están disponibles gratuitamente (denominadas "MIXware" y "MMIXware", respectivamente). También existen varios derivados de los emuladores MIX / MMIX de Knuth. GNU MDK es uno de esos paquetes de software; es gratuito y se ejecuta en una amplia variedad de plataformas.

Su propósito de la educación es bastante similar a John L. Hennessy 's y David A. Patterson ' s DLX arquitectura, de Organización Informática y Diseño - El hardware de interfaz de software .

Arquitectura

MIX es una computadora híbrida binaria - decimal . Cuando se programa en binario, cada byte tiene 6 bits (los valores van de 0 a 63). En decimal, cada byte tiene 2 dígitos decimales (los valores van de 0 a 99). Los bytes se agrupan en palabras de cinco bytes más un signo. La mayoría de los programas escritos para MIX funcionarán en binario o decimal, siempre que no intenten almacenar un valor mayor que 63 en un solo byte.

Una palabra tiene el rango de −1,073,741,823 a 1,073,741,823 (inclusive) en modo binario, y de −9,999,999,999 a 9,999,999,999 (inclusive) en modo decimal. La representación de signo y magnitud de números enteros en la arquitectura MIX distingue entre "−0" y "+0". Esto contrasta con las computadoras modernas, cuya representación en complemento a dos de cantidades enteras incluye una única representación de cero, pero cuyo rango para un número dado de bits incluye un entero negativo más que el número de enteros positivos representables.

Registros MIX
3 0 2 9 2 8 2 7 2 6 2 5 2 4 2 3 2 2 2 1 2 0 1 9 1 8 1 7 1 6 1 5 1 4 1 3 1 2 1 1 1 0 0 9 0 8 0 7 0 6 0 5 0 4 0 3 0 2 0 1 0 0 (posición de bit)
Registros
± A1 A2 A3 A4 A5 rA , acumulador
± X1 X2 X3 X4 X5 rX , extensión
Registros de índice
  ± I1.4 I1.5 rI1 , índice 1
  ± I2.4 I2.5 rI2 , índice 2
  ± I3.4 I3.5 rI3 , índice 3
  ± I4.4 I4.5 rI4 , índice 4
  ± I5.4 I5.5 rI5 , índice 5
  ± I6.4 I6.5 rI6 , índice 6
Contador de programa
  J4 J5 rJ , saltar
Indicadores de código de condición
  O Bandera de desbordamiento
  <=> Bandera de comparación

Registros

Hay 9 registros en MIX:

  • rA : Acumulador (palabra completa, cinco bytes y un signo).
  • rX : Extensión (palabra completa, cinco bytes y un signo).
  • rI1 , rI2 , rI3 , rI4 , rI5 , rI6 : registros de índice (dos bytes y un signo).
  • rJ : Dirección de salto (dos bytes, siempre positiva).

Se supone que un byte tiene al menos 6 bits. La mayoría de las instrucciones pueden especificar cuál de los "campos" (bytes) de un registro se van a modificar, utilizando un sufijo del formulario (primero: último) . El campo cero es el signo de un bit.

MIX también registra si la operación anterior se desbordó y tiene un indicador de comparación de un trit (menor que, igual o mayor que).

Memoria y entrada / salida

La máquina MIX tiene 4000 palabras de almacenamiento (cada una con 5 bytes y un signo), direccionadas de 0 a 3999. También se incluyen una variedad de dispositivos de entrada y salida:

  • Unidades de cinta (dispositivos 0… 7).
  • Unidades de disco o tambor (dispositivos 8… 15).
  • Lector de tarjetas (dispositivo 16).
  • Perforadora de tarjetas (dispositivo 17).
  • Impresora de línea (dispositivo 18).
  • Terminal de máquina de escribir (dispositivo 19).
  • Cinta de papel (dispositivo 20).

Instrucciones

Cada instrucción de máquina en memoria ocupa una palabra y consta de 4 partes: la dirección (2 bytes y el signo de la palabra) en memoria para leer o escribir; una especificación de índice (1 byte, que describe qué registro de índice rI usar) para agregar a la dirección; una modificación (1 byte) que especifica qué partes del registro o la ubicación de la memoria se leerán o alterarán; y el código de operación (1 byte). Todos los códigos de operación tienen un mnemónico asociado.

3 0 2 9 2 8 2 7 2 6 2 5 2 4 2 3 2 2 2 1 2 0 1 9 1 8 1 7 1 6 1 5 1 4 1 3 1 2 1 1 1 0 0 9 0 8 0 7 0 6 0 5 0 4 0 3 0 2 0 1 0 0
± Dirección Índice Modificación Operación

Los programas MIX frecuentemente usan código auto-modificable, en particular para regresar de una subrutina, ya que MIX carece de una pila de retorno automática de subrutinas. El byte de modificación facilita el código de modificación automática , lo que permite que el programa almacene datos en, por ejemplo, la parte de la dirección de la instrucción de destino, dejando el resto de la instrucción sin modificar.

Los programas MIX se construyen típicamente usando el lenguaje ensamblador MIXAL; para ver un ejemplo, consulte la página de la lista de programas de hola mundo .

LDA ADDR,i(0:5) rA := memory[ADDR + rIi];
LDX ADDR,i(0:5) rX := memory[ADDR + rIi];
LD? ADDR,i(0:5) rI? := memory[ADDR + rIi];
LDAN ADDR,i(0:5) rA := - memory[ADDR + rIi];
LDXN ADDR,i(0:5) rX := - memory[ADDR + rIi];
LD?N ADDR,i(0:5) rI? := - memory[ADDR + rIi];
STA ADDR,i(0:5) memory[ADDR + rIi] := rA;
STX ADDR,i(0:5) memory[ADDR + rIi] := rX;
ST? ADDR,i(0:5) memory[ADDR + rIi] := rI?;
STJ ADDR,i(0:5) memory[ADDR + rIi] := rJ;
STZ ADDR,i(0:5) memory[ADDR + rIi] := 0;
ADD ADDR,i(0:5) rA := rA + memory[ADDR + rIi];
SUB ADDR,i(0:5) rA := rA - memory[ADDR + rIi];
MUL ADDR,i(0:5) (rA,rX) := rA * memory[ADDR + rIi];
DIV ADDR,i(0:5)
rA := int( (rA,rX) / memory[ADDR + rIi] );
rX := (rA,rX) % memory[ADDR + rIi];
ENTA ADDR,i rA := ADDR + rIi;
ENTX ADDR,i rX := ADDR + rIi;
ENT? ADDR,i rI? := ADDR + rIi;
ENNA ADDR,i rA := - ADDR - rIi;
ENNX ADDR,i rX := - ADDR - rIi;
ENN? ADDR,i rI? := - ADDR - rIi;
INCA ADDR,i rA := rA + ADDR + rIi;
INCX ADDR,i rX := rX + ADDR + rIi;
INC? ADDR,i rI? := rI? + ADDR + rIi;
DECA ADDR,i rA := rA - ADDR - rIi;
DECX ADDR,i rX := rX - ADDR - rIi;
DEC? ADDR,i rI? := rI? - ADDR - rIi;
CMPA ADDR,i(0:5) comparar rAconmemory[ADDR + rIi];
CMPX ADDR,i(0:5) comparar rXconmemory[ADDR + rIi];
CMP? ADDR,i(0:5) comparar rI?conmemory[ADDR + rIi];
JMP ADDR,i
rJ := address of next instruction;
goto ADDR + rIi;
JSJ ADDR,i goto ADDR + rIi;
JOV ADDR,i
if (overflow) then
   overflow := false; 
   goto ADDR + rIi;
JNOV ADDR,i
if (no overflow) then
    goto ADDR + rIi;
else 
    overflow := false;
JL, JE, JG ADDR,i
JGE, JNE, JLE ADDR,i
if (less, equal, greater) then goto ADDR + rIi;
if (no less, unequal, no greater) then goto ADDR + rIi;
JAN/JAZ/JAP ADDR,i
JANN/JANZ/JANP ADDR,i
if (rA<0 or rA==0 or rA>0) then goto ADDR + rIi;
if (rA>=0 or rA!=0 or rA<=0) then goto ADDR + rIi;
JXN/JXZ/JXP ADDR,i
JXNN/JXNZ/JXNP ADDR,i
if (rX<0 or rX==0 or rX>0) then goto ADDR + rIi;
if (rX>=0 or rX!=0 or rX<=0) then goto ADDR + rIi;
J?N/J?Z/J?P ADDR,i
J?NN/J?NZ/J?NP ADDR,i
si (rI? <0 o rI? == 0 o rI?> 0) entonces vaya a ADDR + rIi;
si (rI?> = 0 o rI?! = 0 o rI? <= 0) entonces vaya a ADDR + rIi;
MOVE ADDR,i(F)
for (n = 0; n < F; n++, rI1++)
    memory[rI1] := memory[ADDR+rIi+n];
SLA/SRA ADDR,i
SLAX/SRAX ADDR,i
SLC/SRC ADDR,i
desplazarse rAa la izquierda / derecha en ADDR+rIibytes
desplazarse (rA,rX)a la izquierda / derecha en ADDR+rIibytes
girar (rA,rX)a la izquierda / derecha en ADDR+rIibytes
NOP hacer nada;
HLT detener la ejecución;
IN ADDR,i(F) leer en un bloque desde la unidad de entrada F
en memory[ADDR + rIi]adelante;
OUT ADDR,i(F) salida de un bloque a la unidad F
de en memory[ADDR + rIi]adelante;
IOC ADDR,i(F) enviar instrucciones de control a la unidad de E / S F;
JRED ADDR,i(F) if (i/o unit F is ready) then goto ADDR + rIi;
JBUS ADDR,i(F) if (i/o unit F is busy) then goto ADDR + rIi;
NUM rA := numerical value of characters in (rA,rX);
CHAR (rA,rX) := character codes representing value of rA;

Implementaciones

MIX ha sido implementado en software por:

Se creó una implementación FPGA de MIX para la placa iCE40HX8K-EVB en 2021.

Ver también

Referencias

enlaces externos