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

Primeros pasos en descripcion de hardware con VHDL


VHDL source code for a signed adder
Image via Wikipedia

Hace un tiempo cuando estudiaba en la U, hice este video para la monitoria de logica digital que dictaba los fines de semana. Aqui lo dejo, quiza sea de ayuda para alguien.

Aunque habia hecho una serie de varios videos, desgraciadamente este es el unico que tengo ahora.

Es una tutoria sobre descripcion de hardware con VHDL incluyendo una práctica con el software Altera Quartus II aunque lo que se examina vale tambien para otros entornos como el de Xilinx o Actel. Se trata de modelar un multiplexor con VHDL para mostrar algo de la descripcion combinatoria y luego se agrega un registro al circuito para mostrar el uso de la funcion rising_edge(). para cada caso se compara con la interpretacion RTL que el sintetizador hace de la descripcion.



Arquitectura DLX


La arquitectura DLX es una arquitectura de computador diseñada con propósitos academicos, es una forma simplificada de la arquitectura MIPS. De su version original se han modificado algunos aspectos con el fin de hacer mas sencilla la comprension de su funcionamiento para los estudiantes que se enfretan a  arquitectura de computadoras por primera vez.  A continuacion traduciré parte de la información encontrada en http://www.csee.umbc.edu/courses/undergraduate/411/spring96/dlx.html 

Informacion general

El procesador DLX usa una arquitectura Load-Store similar a la del procesador MIPS. Al igual que en el procesador MIPS, todas las instrucciones son de 32 bits. Esta decision hace al diseño considerablemente mas sencillo  – Fetching de una instruccion es tan solo cuestion de leer una palabra de 4 bytes desde la memoria.

Conjunto de instrucciones

Formatos de instruccion

Hay 3 formatos de instruccion en DLX:   tipo-I,  tipo-R  y  tipo-J. Una instruccion en DLX siempre debe especificar un opcode sin importar que tipo sea la instruccion, pero la informacion adicional varia con cada tipo o formato de instruccion. 

Las instrucciones tipo-R llevan tres registros en la instruccion: dos registros fuente y un registro destino

Las instrucciones tipo-I (inmediato) llevan un registro fuente, un registro destino y un valor inmediato de 16 bits (que luego es extendido en signo a 32 bits antes de ser usado).

 Las instrucciones tipo-J (jump) o instrucciones de salto llevan solo el opcode y un operando de 26 bits, el cual es usado para calcular la direccion de destino.

Estos formatos de instruccion se resumen en esta tabla

Formato Bits
  31    26 25    21 20    16 15    11 10     6 5        0
R-type 0 Rs1 Rs2 Rd unused opcode
I-type opcode Rs1 Rd immediate
J-type opcode value

Instrucciones

Esta tabla lista las instrucciones que su implementacion de DLX tiene que soportar. El DLX verdadero implementa mas instrucciones, incluyendo algunas para soportar calculos de punto flotante pero fueron descartadas aqui para simplificar la implementacion.

Nota: Las operaciones para cada opcode estan escritas usando sintaxis y operadores del lenguaje C. Todos los valores son rellenados con ceros a la izquierda a menos que esten indicadas con extended(), en cuyo caso estarán rellenas con copias del bit mas a la izquierda en el valor inmediato. Algunas instrucciones tampoco usan todos los campos disponibles en el formato.

Instr. Description Format Opcode Operation (C-style coding)
ADD addsumar R 0x20 Rd = Rs1 + Rs2
ADDI add immediatesumar inmediato I 0x08 Rd = Rs1 + extend(immediate)
AND and R 0x24 Rd = Rs1 & Rs2
ANDI and immediate I 0x0c Rd = Rs1 & immediate
BEQZ branch if equal to zero I 0x04 PC += ( Rs1 == 0 ? extend(immediate) : 0 )
BNEZ branch if not equal to zero I 0x05 PC += ( Rs1 != 0 ? extend(immediate) : 0 )
J jump  saltar J 0x02 PC += extend(value)
JAL jump and link saltar y enlazar J 0x03 R31 = PC + 4 ; PC += extend(value)
JALR jump and link registersaltar y enlazar registro I 0x13 R31 = PC + 4 ; PC = Rs1
JR jump register saltar registro I 0x12 PC = Rs1
LHI load high bits cargar bits superiores I 0x0f Rd = immediate << 16
LW load woRd cargar palabra I 0x23 Rd = MEM[Rs1 + extend(immediate)]
OR or R 0x25 Rd = Rs1 | Rs2
ORI or immediate I 0x0d Rd = Rs1 | immediate
SEQ set if equal asignar si es igual R 0x28 Rd = ( Rs1 == Rs2 ? 1 : 0 )
SEQI set if equal to immediate asignar si es igual a inmediato I 0x18 Rd = ( Rs1 == extend(immediate) ? 1 : 0 )
SLE set if less than or equal asignar si es menor o igual que R 0x2c Rd = ( Rs1 <= Rs2 ? 1 : 0 )
SLEI set if less than or equal to immediate asignar si es menor o igual a inmediato I 0x1c Rd = ( Rs1 <= extend(immediate) ? 1 : 0 )
SLL shift left logical corrimiento logico a la izquierda R 0x04 Rd = Rs1 << ( Rs2 % 8 )
SLLI shift left logical immediate corrimiento logico a la izquierda con inmediato I 0x14 Rd = Rs1 << ( immediate % 8 )
SLT set if less than asignar si es menor que R 0x2a Rd = ( Rs1 < Rs2 ? 1 : 0 )
SLTI set if less than immediate asignar si es menor que inmediato I 0x1a Rd = ( Rs1 < extend(immediate) ? 1 : 0 )
SNE set if not equal asignar si no es igual R 0x29 Rd = ( Rs1 != Rs2 ? 1 : 0 )
SNEI set if not equal to immediate asignar si no es igual a inmediato I 0x19 Rd = ( Rs1 != extend(immediate) ? 1 : 0 )
SRA shift right arithmetic corrimiento aritmetico a la derecha R 0x07 as SRL & see below
SRAI shift right arithmetic immediate corrimiento aritmetico a la derecha con inmediato I 0x17 as SRLI & see below
SRL shift right logical corrimiento logico a la derecha R 0x06 Rd = Rs1 >> ( Rs2 % 8 )
SRLI shift right logical immediate corrimiento logico a la derecha con inmediato I 0x16 Rd = Rs1 >> ( immediate % 8 )
SUB subtract restar R 0x22 Rd = Rs1 – Rs2
SUBI subtract immediate restar inmediato I 0x0a Rd = Rs1 – extend(immediate)
SW store woRd almacenar palabra I 0x2b MEM[Rs1 + extend(immediate)] = Rd
XOR exclusive or  R 0x26 Rd = Rs1 ^ Rs2
XORI exclusive or immediate I 0x0e Rd = Rs1 ^ immediate

Notas adicionales sobre las instrucciones:

  • La instruccion SW usa Rd como registro fuente (el valor que se guarda en la memoria viene del registro Rd)
  • JR y JALR solamente usa Rs1, el valor inmediato y Rd son descartados, no se usan en esta instruccion.
  • SRA y SRAI son desplazamientos aritmeticos. esto significa que en lugar de desplazar ceros desde la izquierda, el bit de signo del operando es replicado SRL y SRA funcionan igual si Rs1 es positivo. Si Rs1 es negativo (bit 31 es 1), entonces 1’s son desplazados dentro desde la izquierda para SRA y SRAI.
  • LHI es usado para cargar los bits superiores de una constante de 32 bits. Por ejemplo, para cargar la constante 0x12345678 en R1 , ejecute las siguientes instrucciones.
                 LHI    R1, #0x1234
                 ORI    R1, #0x5678