La siguiente tabla muestra el porcentaje de reducción de consumo de energía que se puede lograr en cada nivel del diseño digital. Después del nivel RTL, la cantidad de reducción de consumo ya es muy limitada.

Nivel de diseñoGrado de mejora
Nivel de sistema50% ~ 90%
Nivel RTL20% ~ 50%
Nivel de compuertas10% ~ 15%
Nivel de transistores5% ~ 10%
Nivel de layout< 5%

Como un simple programador que escribe Verilog, también se puede participar en el trabajo de reducción de consumo a nivel de sistema, pero el enfoque principal debe estar en la reducción de consumo a nivel RTL.

A continuación, se dividirá en 2 secciones para presentar los métodos comunes para reducir el consumo de energía a nivel RTL.


Paralelismo y pipeline

Para un módulo funcional, se puede implementar mediante paralelismo o mediante pipeline. Ambos métodos intercambian recursos por velocidad. El uso flexible de estos dos métodos en ciertas situaciones puede reducir el consumo de energía.

Procesamiento paralelo

El procesamiento paralelo puede ejecutar múltiples sentencias al mismo tiempo, lo que aumenta la eficiencia de ejecución. Por lo tanto, bajo la condición de cumplir con los requisitos de trabajo, el uso del procesamiento paralelo puede reducir la frecuencia de trabajo del sistema y disminuir el consumo de energía.

Por ejemplo, la descripción del código para implementar una operación de multiplicación y suma de 4 datos usando 1 multiplicador y 2 multiplicadores (en paralelo) es la siguiente:

Ejemplo

//===========================================
//1 multiplier, high speed
module  mul1_hs
    (
        input           clk ,           //200MHz
        input           rstn ,
        input           en  ,
        input [3:0]     mul1 ,          //data in
        input [3:0]     mul2 ,          //data in
        output          dout_en ,
        output [8:0]    dout
     );

    reg                  flag ;
    reg                  en_r ;
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            flag   <= 1'b0 ;
            en_r   <= 1'b0 ;
        end
        else if (en) begin
            flag   <= ~flag ;
            en_r   <= 1'b1 ;
        end
        else begin
            flag   <= 1'b0 ;
            en_r   <= 1'b0 ;
        end
    end

    wire [7:0]           result = mul1 * mul2 ;

    // data output en
    reg [7:0]            res1_r, res2_r ;
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            res1_r         <= 'b0 ;
            res2_r         <= 'b0 ;
        end
        else if (en & !flag) begin
            res1_r         <= result ;
        end
        else if (en & flag) begin
            res2_r         <= result ;
        end
    end

    assign dout_en = en_r & !flag ;
    assign dout = res1_r + res2_r ;

endmodule

//===========================================
// 2 multiplier2, low speed
module  mul2_ls
    (
        input           clk ,           //100MHz
        input           rstn ,
        input           en  ,
        input [3:0]     mul1 ,          //data in
        input [3:0]     mul2 ,          //data in
        input [3:0]     mul3 ,          //data in
        input [3:0]     mul4 ,          //data in
        output          dout_en,
        output [8:0]    dout
     );

    wire [7:0]           result1 = mul1 * mul2 ;
    wire [7:0]           result2 = mul3 * mul4 ;

    //en delay
    reg                  en_r ;
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            en_r           <= 1'b0 ;
        end
        else begin
          en_r           <= en ;
        end
    end

    // data output en
    reg [7:0]            res1_r, res2_r ;
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            res1_r         <= 'b0 ;
            res2_r         <= 'b0 ;
        end
        else if (en) begin
            res1_r         <= result1 ;
            res2_r         <= result2 ;
        end
    end
    assign dout          = res1_r + res2_r ;
    assign dout_en       = en_r ;

endmodule

La descripción del testbench es la siguiente.

Ejemplo

`timescale 1ns/1ps
module test ;
    reg          rstn ;
    //mul1_hs
    reg          hs_clk;
    reg          hs_en ;
    reg [3:0]    hs_mul1 ;
    reg [3:0]    hs_mul2 ;
    wire         hs_dout_en ;
    wire [8:0]   hs_dout ;
    //mul1_ls
    reg          ls_clk = 0;
    reg          ls_en ;
    reg [3:0]    ls_mul1 ;
    reg [3:0]    ls_mul2 ;
    reg [3:0]    ls_mul3 ;
    reg [3:0]    ls_mul4 ;
    wire         ls_dout_en ;
    wire [8:0]   ls_dout ;

    //clock generating
    real         CYCLE_200MHz = 5 ; //
    always begin
        hs_clk = 0 ; #(CYCLE_200MHz/2) ;
        hs_clk = 1 ; #(CYCLE_200MHz/2) ;
    end
    always begin
        @(posedge hs_clk) ls_clk = ~ls_clk ;
    end

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

    //motivation
    initial begin
        hs_mul1   = 0 ;
        hs_mul2   = 16 ;
        hs_en     = 0 ;
        #103 ;
        repeat(12) begin
            @(negedge hs_clk) ;
            hs_en          = 1 ;
            hs_mul1        = hs_mul1 + 1;
            hs_mul2        = hs_mul2 - 1;
        end
        hs_en = 0 ;
    end

    initial begin
        ls_mul1   = 1 ;
        ls_mul2   = 15 ;
        ls_mul3   = 2 ;
        ls_mul4   = 14 ;
        ls_en     = 0 ;
        #103 ;
        @(negedge ls_clk) ls_en = 1;
        repeat(5) begin
            @(negedge ls_clk) ;
           ls_mul1        = ls_mul1 + 2;
           ls_mul2        = ls_mul2 - 2;
           ls_mul3        = ls_mul3 + 2;
           ls_mul4        = ls_mul4 - 2;
        end
        ls_en = 0 ;
    end

    //module instantiation
    mul1_hs    u_mul1_hs
    (
      .clk              (hs_clk),
      .rstn             (rstn),
      .en               (hs_en),
      .mul1             (hs_mul1),
      .mul2             (hs_mul2),
      .dout             (hs_dout),
      .dout_en          (hs_dout_en)
    );

    mul2_ls    u_mul2_ls
    (
      .clk              (ls_clk),
      .rstn             (rstn),
      .en               (ls_en),
      .mul1             (ls_mul1),
      .mul2             (ls_mul2),
      .mul3             (ls_mul3),
      .mul4             (ls_mul4),
      .dout             (ls_dout),
      .dout_en          (ls_dout_en)
    );

    //simulation finish
    always begin
        #100;
        if ($time >= 1000)  begin
            #1 ;
            $finish ;
        end
    end
   
endmodule

El resultado de la simulación es el siguiente.

Como se puede ver en la figura, los resultados de salida de los dos métodos de implementación son consistentes, pero el método de procesamiento paralelo reduce la frecuencia de trabajo a la mitad, el consumo de energía disminuirá y el área de diseño también aumentará.

Procesamiento en pipeline

En«Tutorial de Verilog»Como se mencionó en el «Tutorial de Verilog», un diseño de pipeline de N etapas trabajando continuamente mejora la eficiencia aproximadamente N veces. Al igual que con el diseño paralelo, al usar el diseño de pipeline, también se puede reducir adecuadamente la frecuencia de trabajo para disminuir el consumo de energía.

Desde otro punto de vista, el diseño de pipeline puede dividir una ruta combinacional larga en N etapas de pipeline. La longitud de la ruta se reduce a 1/N de la longitud original. En este momento, si la frecuencia del reloj no cambia, en un período solo es necesario cargar y descargar la capacitancia C/N, en lugar de la capacitancia C original. Por lo tanto, bajo el mismo requisito de frecuencia, se puede usar un voltaje de alimentación más bajo para impulsar el sistema, lo que reduce el consumo de energía.

Supongamos que en un diseño, la ruta crítica es un multiplicador de 32 bits X 32 bits. La capacitancia total de este multiplicador es C y el voltaje de trabajo es V.

Sin pipeline, para alcanzar esta frecuencia de trabajo, el voltaje de trabajo debería ser V.

Al usar un pipeline de dos etapas, esta ruta se divide en dos partes. Para cada parte, la capacitancia total se convierte en C/2. Si se desea alcanzar la frecuencia de trabajo original, el voltaje de trabajo se puede reducir a βV (β<1). El consumo de energía de todo el sistema se reduce a β^2 del original.

Para el método de diseño específico del pipeline, consulte«Tutorial de Verilog»en el capítulo«6.7 Verilog pipeline»sección.


Compartición de recursos y codificación de estados

Compartición de recursos

Cuando en un diseño algunas lógicas de cálculo idénticas se utilizan en varios lugares, se puede usar el método de compartición de recursos para evitar la repetición de múltiples lógicas de cálculo y reducir el consumo de recursos.

Por ejemplo, para una lógica de comparación, la descripción del código sin compartición de recursos es la siguiente:

Ejemplo

    always @(*) begin
        case (mode) :
            3'b000:         result  = 1'b1 ;
            3'b001:         result  = 1'b0 ;
            3'b010:         result  = value1 == value2 ;
            3'b011:         result  = value1 != value2 ;
            3'b100:         result  = value1 > value2 ;
            3'b101:         result  = value1 < value2 ;
            3'b110:         result  = value1 >= value2 ;
            3'b111:         result  = value1 <= value2 ;
        endcase
    end
Optimizando el código anterior, la descripción es la siguiente:
    wire equal_con       = value1 == value2 ;
    wire great_con       = value1 > value2 ;
    always @(*) begin
        case (mode) :
            3'b000:         result  = 1'b1 ;
            3'b001:         result  = 1'b0 ;
            3'b010:         result  = equal_con ;
            3'b011:         result  = equal_con ;
            3'b100:         result  = great_con ;
            3'b101:         result  = !great_con && !equal_con ;
            3'b110:         result  = great_con && equal_con ;
            3'b111:         result  = !great_con ;
        endcase
    end

Cuando el primer método se implementa mediante síntesis, si el optimizador del compilador no está bien hecho, pueden ser necesarios 6 comparadores. El segundo método de compartición de recursos solo necesita 2 comparadores para completar la misma función lógica, por lo que reducirá el consumo de energía en cierta medida.

Codificación de estados

Para algunas señales que cambian con frecuencia, la tasa de conmutación es relativamente alta y el consumo de energía es relativamente grande. Se puede utilizar la codificación de estados para reducir la actividad de conmutación y disminuir el consumo de energía.

Por ejemplo, cuando un contador de alta velocidad trabaja, si se usa el código Gray en lugar de la codificación binaria, solo 1 bit de datos cambia en cada momento, la tasa de conmutación disminuye y el consumo de energía disminuye en consecuencia.

Por ejemplo, al diseñar una máquina de estados, si la codificación de estados antes y después de la transición tiene solo una diferencia de 1 bit, también se reduce la tasa de conmutación.

Aislamiento de operandos

Principio del aislamiento de operandos: si durante un cierto período de tiempo la salida del camino de datos no es útil, al fijar la entrada a un valor constante, la parte del camino de datos no conmuta y el consumo de energía se reduce.

El diagrama del circuito de un multiplicador se muestra a continuación.

Cuando sel0 = 0 o sel1 = 1, el resultado de salida del multiplicador no puede llegar a la entrada del registro a través de los dos Mux. Es decir, el registro no puede almacenar el resultado actual del multiplicador, por lo que esta operación de multiplicación es innecesaria. En estas condiciones, al aplicar el aislamiento de operandos para que el multiplicador no trabaje y permanezca estático, también se puede ahorrar consumo de energía.

Se realiza una optimización del circuito anterior, como se muestra en la siguiente figura.

Después del aislamiento de operandos, cuando sel0 = 0 o sel1 = 1, la entrada del multiplicador es siempre 0, no hay conmutación de señales, el multiplicador no realiza trabajo adicional inútil, por lo que el consumo de energía se reduce.

En general, la operación de aislamiento de operandos ocurre durante la síntesis del código. Este proceso a menudo se puede configurar manualmente y el compilador puede identificarlo automáticamente. Por supuesto, un buen estilo de código, teniendo en cuenta el diseño RTL desde el principio, contribuye a implementar el aislamiento de operandos y, por lo tanto, a reducir el consumo de energía.

Cuando el multiplicador no usa aislamiento de operandos, la descripción del código Verilog es la siguiente:

Ejemplo

//no isolation
module  oper_isolation1
    (
     input                clk ,           //100MHz
     input [1:0]          sel ,
     input [3:0]          din1 ,          //data in
     input [3:0]          din2 ,          //data in
     output reg [7:0]     dout
     );

    reg [7:0]       res ;
    always @(*) begin
        res       = din1 * din2 ;
    end

    always @(posedge clk) begin
        if (sel == 2'b01) begin
            dout   <= res ;
        end
    end
endmodule

Cuando el multiplicador usa aislamiento de operandos, la descripción del código Verilog es la siguiente:

Ejemplo

//using isolation
module  oper_isolation2
    (
    input                clk ,           //100MHz
    input [1:0]          sel ,
    input [3:0]          din1 ,          //data in
    input [3:0]          din2 ,          //data in
    output reg [7:0]     dout
    );

    wire [3:0]           mul1 = sel == 2'b01 ? din1 : 0 ;
    wire [3:0]           mul2 = sel == 2'b01 ? din2 : 0 ;
    reg [7:0]            res ;
    always @(*) begin
        res       = mul1 * mul2 ;
    end

    always @(posedge clk) begin
        if (sel == 2'b01) begin
            dout   <= res ;
        end
    end
endmodule

Descarga del código fuente de este capítulo

Download