数字芯片中的verilog代码描述

　　书接上文，数字芯片中典型的低功耗设计是添加clk gate。另外还有一种方法是并行与流水技术。

　　并行与流水

　　硬件描述语言的一个突出优点就是指令执行的并行性。多条语句能够在相同时钟周期内并行处理多个信号数据。但是当数据串行输入时，指令执行的并行性并不能体现出其优势。而且很多时候有些计算并不能在一个或两个时钟周期内执行完毕，如果每次输入的串行数据都需要等待上一次计算执行完毕后才能开启下一次的计算，那效率是相当低的。流水线就是解决多周期下串行数据计算效率低的问题。一般来讲，对于一个功能模块，可以通过并行的方式实现，也可以通过流水线的方式实现，这两种方法都是用资源换速度。

　　对于并行处理，可以同时处理多条执行语句，使执行效率变高。在满足设计SPEC的前提下，通过并行处理，可减小时钟频率，从而达到降低功耗的目的。举例，若实现4 个数据乘加运算，可以采用 1 个乘法器来实现，也可以通过 2 个乘法器（并行）来实现 ，verilog代码描述分别如下：

　　//1 multiplier， high speedmodule 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） be

　　gin

　　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 speedmodule 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

　　tb测试平台描述如下：

　　`timescale 1ns/1psmodule 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

　　下图为仿真结果，两种实现方法的结果是相同的，但是对于并行处理方法，由于其时钟频率降低了1/2，功耗也会随之降低，但是电路面积会随之增加。

　　

　　对于一个处于连续工作模式的 N 级流水线，效率提升N倍。与并行设计类似，流水线设计也可以通过降低工作频率，达到降低功耗的目的。除此之外，我们可以将流水线设计分成 N 级流水线，假设新的路径长度为Lnew，原始路径长度为Lold，则Lnew=1/N*Lold。如果时钟频率保持固定，则在一个周期内，不需要对原来的电容 C 进行充放电，只需要对电容 C/N 进行充放电。因此可以采用较低的电压来驱动芯片电路，从而达到降低功耗的目的。

　　资源共享与状态编码

　　对于某设计，一个相同的逻辑在多处被调用时，可以对该逻辑进行资源共享，以降低功耗。例如，对于一个比较逻辑，没有使用资源共享的代码描述如下：

　　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

　　改进后，使用资源共享的代码描述如下：

　　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

　　第一种方法综合实现时，如果编译器优化做的不好，可能需要 6 个比较器。第二种资源共享的方法只需要 2 个比较器即可完成相同的逻辑功能，因此在一定程度会减少功耗。

　　对于一些变化频繁的信号，翻转率相对较高，功耗相对较大。可以利用状态编码的方式来降低开关活动，减少功耗。例如高速计数器工作时，使用格雷码代替二进制编码时，每一时刻只有 1bit 的数据翻转，翻转率降低，功耗随之降低。例如进行状态机设计时，状态机切换前后的状态编码如果只有 1bit 的差异，也会减少翻转率。

　　操作数隔离

　　操作数隔离就是在进行一些操作比如选择器的时候，我们选择的那个选项有A和B，但是如果我们直到选择的是A，那么B之前一大堆计算就显得没有必要了。所以操作数隔离也就是增加一些选择器件，如果这个操作数不需要的话就不选择它以及不进行之前计算这个操作数所需要的操作。 没有使用操作数隔离时，Verilog 代码描述如下：

　　module isolated（A，B，C，D，clk，clr，choose，result）;

　　input wire clk;input wire clr;input wire ［1:0］choose;input wire ［31:0］A;input wire ［31:0］B;input wire ［31:0］C;input wire ［31:0］D;output reg ［31:0］result; wire ［31:0］choose_a;wire ［31:0］choose_b;wire ［31:0］choose_c;wire ［31:0］choose_d;

　　//这是一个简单的mux，先计算出A，B，C，D的值再选择 assign choose_a = A*B;assign choose_b = A+B+C+D;assign choose_c = B*C;assign choose_d = C*D; always@（posedge clk，posedge clr）begin if（clr） result 《= 0;else begin if（choose == 2‘b00） result 《= choose_a;else if（choose == 2’b01） result 《= choose_b;else if（choose == 2‘b10） result 《= choose_c;else result 《= choose_d;endendendmodule

　　使用操作数隔离时，Verilog 代码描述如下：

　　module isolated2（A，B，C，D，clk，clr，choose，result）;

　　input wire clk;input wire clr;input wire ［1:0］choose;input wire ［31:0］A;input wire ［31:0］B;input wire ［31:0］C;input wire ［31:0］D;output reg ［31:0］result; reg ［31:0］choose_A;reg ［31:0］choose_B;reg ［31:0］choose_C;reg ［31:0］choose_D;reg ［1:0］cho;//这是一个使用了isolated的mux，先根据信号然后相应计算所需的A，B，C或者D的值always@（posedge clk，posedge clr

）begin if（clr） begin choose_A 《= 0; choose_B 《= 0; choose_C 《= 0; choose_D

《= 0;cho 《= 0;endelse if（choose == 2’b00） begin choose_A 《= A; choose_B 《= B; choose_C 《= choose_C; choose_D 《= choose_D; cho 《= 0; endelse if（choose == 2‘b01）

begin choose_A 《= A; choose_B 《= B; choose_C 《= C; choose_D

《= D; cho 《= 1; endelse if（choose == 2’b10） begin choose_A 《= choose_A; choose_B 《= B; choose_C 《= C; choose_D 《= choose_D; cho 《= 2; endelse begin choose_A 《= choose_A; choose_B

《= choose_B; choose_C 《= C; choose_D 《= D; cho 《= 3; endendalways@（posedge clk，posedge clr）begin if（clr） result 《= 0;else begin if（cho == 2‘b00） result 《= choose_A*choose_B;

lse if（cho == 2’b01） result 《= choose_A+choose_B+choose_C+choose_D;else if（cho == 2‘b10） result 《= choose_B*choose_C; else result 《= choose_C*choose_D;endend

　　endmodule

　　参考文献： https://www.runoob.com/w3cnote/verilog2-rtl-low-power-design-1.html

　　编辑：黄飞