Información de la Tarea

Estudiante: Andrés Cruz Chipol

Curso: Arquitectura De Computadoras

Fecha de entrega: 26 de marzo de 2026

Tarea 6: Medición del Rendimiento (Throughput) del Oscilador Caótico

Objetivo

Calcular el rendimiento (Throughput) tanto del diseño en hardware dedicado como de la implementación analógica programada en el procesador RISC0, implementando instrucciones de contador para obtener evidencia empírica.

1. Diseño de las Nuevas Instrucciones (TICS y MOVT)

Para cumplir con los requerimientos, agregamos al ISA del RISC0 (RISC0.v) y a su ensamblador (assembler.py) un contador interno de 32 bits junto con 3 variantes de instrucción dedicadas:

TICS 1 (Limpiar e iniciar): Reinicia el registro contador a 0 y habilita el conteo progresivo cada flanco de reloj.
TICS 0 (Parar contador): Deshabilita el conteo, congelando el último número de ciclos calculado.
MOVT Rx (Mover a registro): Tal como lo hace la instrucción MOVH, MOVT toma el valor del registro contador y lo copia a un registro de propósito general dado (ej. R11), permitiendo guardar la captura en memoria externa.

Modificaciones a nivel Arquitectura (Hardware Verilog)

En el código fuente del procesador (RISC0.v), construimos la lógica de control para decodificar las instrucciones TICS (código de operación 12) y MOVT (código 13). Además, el bloque de hardware se encarga de reiniciar, arrancar o detener el contador tics_counter en cada flanco del reloj si la bandera enable está activa (tics_enable):

assign TICS_INST = ~p & (op == 12);
assign RD_TICS   = ~p & (op == 13);

// La salida de la ALU direcciona el valor del registro TICS si la instrucción es MOVT
assign aluRes =
  MOV ? (q ?
    (~u ? {{16{v}}, imm} : {imm, 16'b0}) :
    (~u ? C0 : (~v ? H : {N, Z, C, OV, 20'b0, 8'b10100000}))) :
  RD_TICS ? tics_counter :
  LSL ? t3 :
  // ... (otras operaciones)

always @ (posedge clk) begin
  if (~rst) begin
    tics_counter <= 0;
    tics_enable <= 0;
  end else begin
    if (TICS_INST) begin
        tics_enable <= imm[0];
        if (imm[0]) tics_counter <= 0;     // TICS 1: Limpiar e iniciar
    end else if (tics_enable) begin
        tics_counter <= tics_counter + 1;  // Conteo de ciclos libre
    end
  end
  // ...

Modificaciones en el Ensamblador (Python)

Para que el compilador del RISC0 traduzca el texto asamblado del usuario al formato binario hexadecimal operable por la arquitectura, expandimos las tablas de mapeo y empaquetado de memoria en el script (assembler.py):

# 1. Definición estructural de los argumentos de instrucción
 { 'op' : 'tics', 'id' : 20, 'args' : 1 },
 { 'op' : 'movt', 'id' : 31, 'args' : 1 },

# ...
# 2. Traducción a bloque binario nativo del CPU RISC0 (lcode de 32-bits)
      elif op==30:
        a = self.code[i][2]
        lcode = 0 | 2 << 28 | a << 24
      elif op==31: # MOVT (Estructurado análogo a la instrucción de 1 arg MOVH)
        a = self.code[i][2]
        lcode = 0 | 0 << 28 | a << 24 | (13 << 16)
      elif op==20: # TICS
        a = self.code[i][1]
        lcode = 0 | 12 << 16 | (a & 0xffff)

Código Integrado en el Oscilador (`lu_oscillator.asm`)

Modificamos el bucle matemático para usar estas instrucciones, midiendo estrictamente la integración sin la transmisión UART:

IntegrationLoop:
    # 1. Limpiar e iniciar conteo de ciclos
    TICS 1

    # ... (Instrucciones de cálculo: Euler, PWL, Mutiplicaciones, etc) ...

    # 2. Parar el contador al tener X, Y, Z resueltas
    TICS 0

    # 3. Copiar el contador a un registro dado (de forma análoga a MOVH)
    MOVT R11

    # Escribir R11 en la dirección 16300 para interceptarla con el Testbench
    ST R11 R0 16300

EndLoop:
    BR EndLoop

2. Evidencia del Número de Ciclos Hardware vs RISC0

A) Diseño en Hardware Dedicado RTL PURO

En la implementación clásica de hardware dedicada elaborada previamente, el oscilador caótico de Lü funciona con una ruta de datos (Datapath) estática. Evidencia del número de ciclos: En su código de Verilog, el bloque de asignación principal funciona con la estructura:

always @(posedge clk) begin
    X <= X_next;
    Y <= Y_next;
    Z <= Z_next;
end

Al tener un flujo directo o pipeline dedicado que calcula el estado siguiente en lógica combinacional, el hardware actualiza el sistema en exactamente 1 ciclo de reloj por cada iteración del modelo.

B) Diseño en Software Procesador RISC0

Empleando nuestro archivo de banco de pruebas dinámico (RISC0Top_tb_monitor.v) interceptamos el valor arrojado por el contador internamente durante la simulación generada (./simular.sh):

   THROUGHPUT (Ciclos de reloj por iteracion):        190

Evidencia del número de ciclos: La simulación verificada imprime un total exacto de $m = 190$ ciclos por obtener el resultado de una iteración completa del oscilador caótico en el procesador RISC0.

3. Comparativa de Rendimientos (Throughput)

La fórmula de throughput en resultados por segundo es: 1/seg (resultados/seg) = Frecuencia de operación / Ciclos_de_reloj

Rendimiento del Diseño en Hardware Dedicado

Frecuencia libre: 100 MHz (100,000,000 Hz)
Ciclos de reloj: 1 ciclo
Throughput: 100,000,000 / 1 = 100,000,000 resultados/seg.

Rendimiento del RISC0

Frecuencia operativa libre: 25 MHz (25,000,000 Hz). (Frecuencia mermada por el uso del multiplicador secuencial interno del RISC0).
Ciclos de reloj: 190 ciclos
Throughput: 25,000,000 / 190 = ~131,578 resultados/seg.

Conclusión Final

Hardware: 100,000,000 resultados/s
RISC0: 131,578 resultados/s

Debido a que el procesador de propósito general toma 190 ciclos procesando una instrucción a la vez (sumar, leer memoria, ramificar), su procesamiento algorítmico resulta ser alrededor de ~760 veces más lento frente al rendimiento de la ruta de datos que calculaba la misma ecuación integradora de forma cien por ciento paralela en un (1) sólo flanco de reloj.

Tarea 6: Medición del Rendimiento (Throughput) en RISC0 vs Hardware Dedicado