Arquitectura Zetta


La arquitectura Zetta fue diseñada por mi mismo con el fin de simplificar al máximo el nivel de complejidad de comprensión e implementación de una arquitectura Load-Store básica, por ello incluye un muy limitado conjunto de instrucciones, su implementación se presta para ser monociclo aunque también puede implementarse en versión multiciclo y extenderse a un paradigma pipelined. Esta basada en la arquitectura DLX sin embargo no es compatible con ella ya que pose un juego de instrucciones distinto.

Características

  • Hasta 29 registros de propósito general
  • 1 Registro de banderas
  • 1 Registro de dirección de retorno
  • 1 Registro de contador de programa
  • Tamaño del registro de propósito general: 32 bits
  • Ancho de instrucción: 32 bits
  • Ancho bus de memoria de instrucciones: Max 26-bits para saltos de memoria completa
  • Memoria de programa direccionable en un salto: 64MB
  • Memoria de datos direccionable: 4GB

Formatos de instrucción

Formato Bits
31 26 25 21 20 16 15 11 10 0
R-Type Opcode Rd Rs1 Rs2 Sin usar
I-Type Opcode Rd Rs1 Immediate
J-Type Opcode Value

Los valores sin usar tienen que estar puestos a cero.

Instrucciones

Para el campo operación describe la instrucción a nivel funcional usando la sintaxis del lenguaje C.

Donde Reg es el arreglo del banco de registros, Mem el arreglo de posiciones de memoria y Flags el arreglo de banderas.
Asumir:
#define rDest Reg[Rd]
#define rSrc1 Reg[Rs1]
#define rSrc2 Reg[Rs2]
#define rPC Reg[31]
#define rRet Reg[30]
#define ZF Flags[0]
#define GF Flags[1]
#define LF Flags[2]
void updateFlags() { ZF=rDest==0; GF=rDest>0; LF=rDest<0; }

Instr Descripción Operación
ADD Sumar rDest =rSrc1 + rSrc2; updateFlags();
SUB Restar rDest = rSrc1 – rSrc2; updateFlags();
AND AND bit a bit rDest = rSrc1 & rSrc2; updateFlags();
OR OR bit a bit rDest = rSrc1 | rSrc2; updateFlags();
NOT NOT bit a bit rDest = ~rSrc1; updateFlags();
J Saltar rRet = rPC; rPC += Value;
JR Saltar con registro rRet= rPC; rPC = rDest;
JE Saltar si es igual rRet= rPC; if(ZF) rPC += Value;
JNE Saltar si no es igual rRet= rPC; if(!ZF) rPC += Value;
JL Saltar si es menor rRet= rPC; if(LF) rPC += Value;
JG Saltar si es mayor rRet= rPC; if(GF) rPC += Value;
SL Corrimiento lógico a la izquierda rDest = rSrc1 << rSrc2; updateFlags();
SR Corrimiento lógico a la derecha rDest = rSrc1 >> rSrc2; updateFlags();
MUL Multiplicación rDest = rSrc1 * rSrc2; updateFlags();
MOV Mover registro rDest = rSrc1;
LH Cargar parte alta rDest = Immediate << 16;
LL Cargar parte baja rDest |= Immediate; updateFlags();
LW Cargar palabra rDest = Mem[rSrc1];
SW Almacenar palabra Mem[rRd] = rSrc1;
Anuncios

2 thoughts on “Arquitectura Zetta

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s