Palabras clave: pipeline, multiplicador

Una de las ventajas más destacadas de los lenguajes de descripción de hardware es el paralelismo en la ejecución de instrucciones. Múltiples sentencias pueden procesar simultáneamente múltiples señales de datos en el mismo ciclo de reloj.

Sin embargo, cuando los datos se ingresan en serie, el paralelismo en la ejecución de instrucciones no muestra su ventaja. Además, en muchos casos algunos cálculos no pueden completarse en uno o dos ciclos de reloj. Si cada dato de entrada en serie tiene que esperar a que finalice el cálculo anterior para poder iniciar el siguiente, la eficiencia es bastante baja. El pipeline es la solución al problema de la baja eficiencia del cálculo de datos en serie en múltiples ciclos.

Pipeline

La idea básica del pipeline es: descomponer un proceso repetitivo en varios subprocesos, cada uno implementado por un componente funcional dedicado. Al escalonar en el tiempo múltiples procesos de procesamiento y hacerlos pasar secuencialmente por las etapas funcionales, cada subproceso puede ejecutarse en paralelo con otros subprocesos.

Supongamos que el proceso de lavado de ropa en una lavandería se divide en 4 etapas: recoger la ropa, lavarla, secarla y guardarla en el armario. Cada etapa tarda media hora en completarse, por lo que lavar una vez la ropa toma 2 horas.

Considerando el peor caso, la lavandería solo tiene una lavadora, una secadora y un armario. Si cada media hora llega un lote de ropa para lavar, y cada vez hay que esperar 2 horas a que el lote anterior termine, entonces el tiempo necesario para lavar 4 lotes de ropa es de 8 horas.

El diagrama es el siguiente:

Al actualizar el equipo de esta lavandería, se introducen 4 conjuntos de equipos de lavado y el personal aumenta a 4 personas, cada una responsable de una etapa del lavado. Así, cada lote de ropa puede ser puesto a tiempo por la misma persona en diferentes lavadoras. Como los tiempos están escalonados, cada lote de ropa puede ser lavado, secado y guardado por la misma persona en diferentes equipos y periodos de tiempo (media hora). El diagrama es el siguiente.

Se puede observar que lavar 4 lotes de ropa solo toma 3 horas y media, la eficiencia mejora notablemente.

De hecho, después de 2 horas, el primer equipo de lavado ya ha completado el proceso de lavado y está inactivo. Si en ese momento llega el quinto lote de ropa, el primer equipo puede comenzar a trabajar de nuevo. Y así sucesivamente, mientras los lotes de ropa sigan entrando, los 4 equipos de lavado pueden completar sin interrupción el proceso de limpieza de toda la ropa. Además, excepto el primer lote que tarda 2 horas, a partir de entonces cada media hora se completará el lavado de un lote.

Cuantos más lotes de ropa haya, más evidente será el tiempo ahorrado. Si hay N lotes de ropa, el tiempo necesario es de (4+N) medias horas.

Por supuesto, el proceso de lavado actualizado también tiene desventajas. El aumento de equipos y personal incrementa el costo de inversión, reduce el espacio restante en la lavandería y hace que el estado de trabajo parezca más ocupado.

Similar al proceso de lavado de ropa, la ruta de procesamiento de datos también puede verse como una línea de producción. Cada unidad de procesamiento digital en la ruta puede considerarse una etapa, que introduce retraso.

El diseño con pipeline consiste en dividir sistemáticamente la ruta en unidades de procesamiento digital (etapas) e insertar registros entre las unidades para almacenar temporalmente los datos de las etapas intermedias. Las unidades divididas pueden ejecutarse en paralelo por etapas, sin influirse entre sí. Por lo tanto, el diseño con pipeline puede mejorar la tasa de transferencia de datos, es decir, aumentar la velocidad de procesamiento de los datos.

La desventaja del diseño con pipeline es que cada etapa de procesamiento requiere registros adicionales para guardar el estado de cálculo intermedio, y la ejecución paralela de múltiples instrucciones inevitablemente aumentará el consumo de potencia.

A continuación, diseñaremos un multiplicador y compararemos si se utiliza o no el diseño con pipeline.


Diseño de multiplicador general

Prefacio

Quizás alguien pregunte: ¿no es más rápido y simple usar directamente el signo de multiplicación*para completar la multiplicación de 2 números?

Si tienes esta duda, significa que tu comprensión de los lenguajes de descripción de hardware aún es insuficiente. Como se dijo antes, Verilog describe circuitos de hardware. Si usas directamente el signo de multiplicación para completar el proceso de multiplicación, el compilador también mapeará esta expresión de multiplicación a un multiplicador predeterminado al compilar, pero su estructura interna no se conoce.

Por ejemplo, en el diseño con FPGA, se puede llamar directamente al núcleo IP para generar un multiplicador de alto rendimiento. Cuando el ancho de bits es pequeño, el resultado puede obtenerse en un ciclo; cuando el ancho es mayor, también se puede generar en pipeline. Siempre que se cumplan los requisitos, se puede usar con precaución*o llamar directamente al IP para completar la operación de multiplicación.

Pero el multiplicador IP también tiene muchos defectos, como la limitación del ancho de bits, tiempos desconocidos, etc. Especialmente el uso del signo de multiplicación puede ocultar una gran incertidumbre en el diseño digital.

En muchas ocasiones, la multiplicación por constantes se implementa mediante desplazamiento y suma, por ejemplo:

Ejemplo

A = A<<1 ;       //Completar A * 2
A = (A<<1) + A ;   //Corresponde a A * 3
A = (A<<3) + (A<<2) + (A<<1) + A ; //Corresponde a A * 15

Con un registro de desplazamiento y un sumador se puede completar la operación de multiplicar por 3. Pero multiplicar por 15 requiere 3 registros de desplazamiento y 3 sumadores (por supuesto, multiplicar por 15 se puede hacer mediante desplazamiento y resta).

A veces, un circuito digital no puede completar la suma de múltiples variables simultáneamente en un solo ciclo. Por lo tanto, en el diseño digital, la operación de suma más segura es sumar solo 2 datos al mismo tiempo; el peor diseño es sumar 4 o más datos al mismo tiempo.

Si en el diseño hay una operación que suma 4 datos al mismo tiempo, esa parte del diseño será peligrosa y puede provocar que no se cumplan los tiempos.

En este caso, resulta necesario diseñar un multiplicador con pipeline de parámetros configurables y tiempos controlables.

Principio de diseño

Similar a la multiplicación decimal, el proceso de calcular 13 por 5 se muestra a continuación:

De esto se deduce que el multiplicando se desplaza y acumula según el bit correspondiente del multiplicador, completando así el proceso de multiplicación.

Suponiendo que solo se puede completar una acumulación por ciclo, el número mínimo de ciclos de reloj para un cálculo de multiplicación es exactamente el ancho de bits del multiplicador. Por lo tanto, se recomienda usar el número de ancho de bits menor como multiplicador, así el ciclo de cálculo es corto.

Diseño del multiplicador

Considerando que cada operación de multiplicación solo puede generar un resultado (diseño sin pipeline), el código de diseño es el siguiente.

Ejemplo

module    mult_low
    #(parameter N=4,
      parameter M=4)
     (
      input                     clk,
      input                     rstn,
      input                     data_rdy ,  //Habilitación de entrada de datos
      input [N-1:0]             mult1,      //Multiplicando
      input [M-1:0]             mult2,      //Multiplicador

      output                    res_rdy ,   //Habilitación de salida de datos
      output [N+M-1:0]          res         //Resultado de la multiplicación
      );

    //calculate counter
    reg [31:0]           cnt ;
    //Contador de ciclos de multiplicación
    wire [31:0]          cnt_temp = (cnt == M)? 'b0 : cnt + 1'b1 ;
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            cnt    <= 'b0 ;
        end
        else if (data_rdy) begin    //Comenzar a contar cuando la habilitación de datos esté activa
            cnt    <= cnt_temp ;
        end
        else if (cnt != 0 ) begin  //Evitar que el terminal de habilitación de entrada dure demasiado poco
            cnt    <= cnt_temp ;
        end
        else begin
            cnt    <= 'b0 ;
        end
    end

    //multiply
    reg [M-1:0]          mult2_shift ;
    reg [M+N-1:0]        mult1_shift ;
    reg [M+N-1:0]        mult1_acc ;
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            mult2_shift    <= 'b0 ;
            mult1_shift    <= 'b0 ;
            mult1_acc      <= 'b0 ;
        end
        else if (data_rdy && cnt=='b0) begin  //Inicialización
            mult1_shift    <= {{(N){1'b0}}, mult1} << 1 ;  
            mult2_shift    <= mult2 >> 1 ;  
            mult1_acc      <= mult2[0] ? {{(N){1'b0}}, mult1} : 'b0 ;
        end
        else if (cnt != M) begin
            mult1_shift    <= mult1_shift << 1 ;  //Multiplicando multiplicado por 2
            mult2_shift    <= mult2_shift >> 1 ;  //Desplazar el multiplicador a la derecha para facilitar la comprobación
            //Comprobar si el bit correspondiente del multiplicador es 1; si es 1, acumular
            mult1_acc      <= mult2_shift[0] ? mult1_acc + mult1_shift : mult1_acc ;
        end
        else begin
            mult2_shift    <= 'b0 ;
            mult1_shift    <= 'b0 ;
            mult1_acc      <= 'b0 ;
        end
    end

    //results
    reg [M+N-1:0]        res_r ;
    reg                  res_rdy_r ;
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            res_r          <= 'b0 ;
            res_rdy_r      <= 'b0 ;
        end  
        else if (cnt == M) begin
            res_r          <= mult1_acc ;  //Generar el resultado al final del ciclo de multiplicación
            res_rdy_r      <= 1'b1 ;
        end
        else begin
            res_r          <= 'b0 ;
            res_rdy_r      <= 'b0 ;
        end
    end

    assign res_rdy       = res_rdy_r;
    assign res           = res_r;

endmodule

testbench

Ejemplo

`timescale 1ns/1ns

module test ;
    parameter    N = 8 ;
    parameter    M = 4 ;
    reg          clk, rstn;
 
   //clock
    always begin
        clk = 0 ; #5 ;
        clk = 1 ; #5 ;
    end

   //reset
    initial begin
        rstn      = 1'b0 ;
        #8 ;      rstn      = 1'b1 ;
    end

    //no pipeline
    reg                  data_rdy_low ;
    reg [N-1:0]          mult1_low ;
    reg [M-1:0]          mult2_low ;
    wire [M+N-1:0]       res_low ;
    wire                 res_rdy_low ;

    //Usar estímulo periódico de tarea
    task mult_data_in ;  
        input [M+N-1:0]   mult1_task, mult2_task ;
        begin
            wait(!test.u_mult_low.res_rdy) ;  //not output state
            @(negedge clk ) ;
            data_rdy_low = 1'b1 ;
            mult1_low = mult1_task ;
            mult2_low = mult2_task ;
            @(negedge clk ) ;
            data_rdy_low = 1'b0 ;
            wait(test.u_mult_low.res_rdy) ; //test the output state
        end
    endtask

    //driver
    initial begin
        #55 ;
        mult_data_in(25, 5 ) ;
        mult_data_in(16, 10 ) ;
        mult_data_in(10, 4 ) ;
        mult_data_in(15, 7) ;
        mult_data_in(215, 9) ;
    end

    mult_low  #(.N(N), .M(M))
    u_mult_low
    (
      .clk              (clk),
      .rstn             (rstn),
      .data_rdy         (data_rdy_low),
      .mult1            (mult1_low),
      .mult2            (mult2_low),
      .res_rdy          (res_rdy_low),
      .res              (res_low));

   //simulation finish
   initial begin
      forever begin
         #100;
         if ($time >= 10000)  $finish ;
      end
   end

endmodule // test

El resultado de la simulación es el siguiente.

Como se muestra en la figura, los 2 datos de entrada obtienen el resultado correcto de la multiplicación después de un retraso de 4 ciclos. Incluyendo el tiempo de retraso de los datos enviados en el medio, calcular 4 multiplicaciones requiere aproximadamente 20 ciclos de reloj.

Diseño de multiplicador con pipeline

A continuación se guardan los estados intermedios del proceso de multiplicación para permitir el trabajo en pipeline. El código de diseño es el siguiente.

El archivo de código para el proceso de cálculo de una sola acumulación es el siguiente (mult_cell.v):

Ejemplo

module    mult_cell
    #(parameter N=4,
      parameter M=4)
    (
      input                     clk,
      input                     rstn,
      input                     en,
      input [M+N-1:0]           mult1,      //Multiplicando
      input [M-1:0]             mult2,      //Multiplicador
      input [M+N-1:0]           mult1_acci, //Resultado de la acumulación anterior

      output reg [M+N-1:0]      mult1_o,     //Valor guardado después de desplazar el multiplicando
      output reg [M-1:0]        mult2_shift, //Valor guardado después de desplazar el multiplicador
      output reg [N+M-1:0]      mult1_acco,  //Resultado de la acumulación actual
      output reg                rdy );

    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            rdy            <= 'b0 ;
            mult1_o        <= 'b0 ;
            mult1_acco     <= 'b0 ;
            mult2_shift    <= 'b0 ;
        end
        else if (en) begin
            rdy            <= 1'b1 ;
            mult2_shift    <= mult2 >> 1 ;
            mult1_o        <= mult1 << 1 ;
            if (mult2[0]) begin
                //Si el bit correspondiente del multiplicador es 1, acumular
                mult1_acco  <= mult1_acci + mult1 ;  
            end
            else begin
                mult1_acco  <= mult1_acci ; //Si el bit correspondiente del multiplicador es 1, mantener
            end
        end
        else begin
            rdy            <= 'b0 ;
            mult1_o        <= 'b0 ;
            mult1_acco     <= 'b0 ;
            mult2_shift    <= 'b0 ;
        end
    end

endmodule

Instanciación de nivel superior

La instanciación múltiple de módulos completa múltiples acumulaciones. El archivo de código es el siguiente (mult_man.v):

Ejemplo

module    mult_man
    #(parameter N=4,
      parameter M=4)
    (
      input                     clk,
      input                     rstn,
      input                     data_rdy ,
      input [N-1:0]             mult1,
      input [M-1:0]             mult2,

      output                    res_rdy ,
      output [N+M-1:0]          res );

    wire [N+M-1:0]       mult1_t [M-1:0] ;
    wire [M-1:0]         mult2_t [M-1:0] ;
    wire [N+M-1:0]       mult1_acc_t [M-1:0] ;
    wire [M-1:0]         rdy_t ;

    //La primera instanciación equivale a la inicialización, no se puede usar la sentencia generate
    mult_cell      #(.N(N), .M(M))
    u_mult_step0
    (
      .clk              (clk),
      .rstn             (rstn),
      .en               (data_rdy),
      .mult1            ({{(M){1'b0}}, mult1}),
      .mult2            (mult2),
      .mult1_acci       ({(N+M){1'b0}}),
      //output
      .mult1_acco       (mult1_acc_t[0]),
      .mult2_shift      (mult2_t[0]),
      .mult1_o          (mult1_t[0]),
      .rdy              (rdy_t[0]) );

    //Instanciación múltiple de módulos, usando sentencia generate
    genvar               i ;
    generate
        for(i=1; i<=M-1; i=i+1) begin: mult_stepx
            mult_cell      #(.N(N), .M(M))
            u_mult_step
            (
              .clk              (clk),
              .rstn             (rstn),
              .en               (rdy_t[i-1]),
              .mult1            (mult1_t[i-1]),
              .mult2            (mult2_t[i-1]),
              //El resultado de la acumulación anterior se usa como entrada de la siguiente acumulación
              .mult1_acci       (mult1_acc_t[i-1]),
              //output
              .mult1_acco       (mult1_acc_t[i]),                                      
              .mult1_o          (mult1_t[i]),  //Transferencia del estado de desplazamiento del multiplicando
              .mult2_shift      (mult2_t[i]),  //Transferencia del estado de desplazamiento del multiplicador
              .rdy              (rdy_t[i]) );
        end
    endgenerate

    assign res_rdy       = rdy_t[M-1];
    assign res           = mult1_acc_t[M-1];

endmodule

testbench

Agregue la siguiente descripción de simulación al testbench del ejemplo de diseño de multiplicador sin pipeline para obtener el resultado de simulación de la multiplicación en pipeline.

Los 2 canales de datos son entrada en serie ininterrumpida y cuentan con un módulo de autoverificación que puede determinar automáticamente la corrección del resultado de la multiplicación.

Ejemplo

    reg          data_rdy ;
    reg [N-1:0]  mult1 ;
    reg [M-1:0]  mult2 ;
    wire                 res_rdy ;
    wire [N+M-1:0]       res ;

    //driver
    initial begin
        #55 ;
        @(negedge clk ) ;
        data_rdy  = 1'b1 ;
        mult1  = 25;      mult2      = 5;
        #10 ;      mult1  = 16;      mult2      = 10;
        #10 ;      mult1  = 10;      mult2      = 4;
        #10 ;      mult1  = 15;      mult2      = 7;
        mult2      = 7;   repeat(32)    #10   mult1   = mult1 + 1 ;
        mult2      = 1;   repeat(32)    #10   mult1   = mult1 + 1 ;
        mult2      = 15;  repeat(32)    #10   mult1   = mult1 + 1 ;
        mult2      = 3;   repeat(32)    #10   mult1   = mult1 + 1 ;
        mult2      = 11;  repeat(32)    #10   mult1   = mult1 + 1 ;
        mult2      = 4;   repeat(32)    #10   mult1   = mult1 + 1 ;
        mult2      = 9;   repeat(32)    #10   mult1   = mult1 + 1 ;
    end

    //Desplazar los datos de entrada para facilitar la verificación posterior
    reg  [N-1:0]   mult1_ref [M-1:0];
    reg  [M-1:0]   mult2_ref [M-1:0];
    always @(posedge clk) begin
        mult1_ref[0] <= mult1 ;
        mult2_ref[0] <= mult2 ;
    end

    genvar         i ;
    generate
        for(i=1; i<=M-1; i=i+1) begin
            always @(posedge clk) begin
            mult1_ref[i] <= mult1_ref[i-1];
            mult2_ref[i] <= mult2_ref[i-1];
            end
        end
    endgenerate
   
    //Autoverificación
    reg  error_flag ;
    always @(posedge clk) begin
        # 1 ;
        if (mult1_ref[M-1] * mult2_ref[M-1] != res && res_rdy) begin
            error_flag <= 1'b1 ;
        end
        else begin
            error_flag <= 1'b0 ;
        end
    end

    //module instantiation
    mult_man  #(.N(N), .M(M))
     u_mult
     (
      .clk              (clk),
      .rstn             (rstn),
      .data_rdy         (data_rdy),
      .mult1            (mult1),
      .mult2            (mult2),
      .res_rdy          (res_rdy),
      .res              (res));

Resultado de la simulación

El resultado de la simulación de las primeras decenas de ciclos de reloj es el siguiente.

Como se muestra en la figura, la señal de juicio error_flag del resultado de la simulación permanece en 0, lo que indica que el diseño de la multiplicación es correcto.

Los datos se ingresan en serie continuamente bajo el impulso del reloj. Después de un retraso de 4 ciclos de reloj, los resultados de la multiplicación también se generan sin retraso en cada ciclo de reloj, completando el trabajo en pipeline.

En comparación con el multiplicador que generalmente no usa pipeline, la eficiencia del cálculo de multiplicación ha mejorado enormemente.

Sin embargo, los recursos de registros utilizados por el multiplicador con pipeline son aproximadamente 4 veces los del multiplicador sin pipeline anterior.

Por lo tanto, en un diseño digital, si se adopta o no un diseño de pipeline, se deben sopesar tanto los recursos como la eficiencia.

Descarga del código fuente

Download