寄存器堆的设计
实验内容寄存器堆(RegisterFile)ra0,rd0;ra1,rd1
![实验内容寄存器堆(RegisterFile)ra0,rd0;ra1,rd1](https://img.taocdn.com/s3/m/3ba863810242a8956bece4fb.png)
• 检查下载测试是否正确
• 检查代码设计,代码是否独立完成
2019-3-28
2019春_计算机组成原理实验_CS-USTC
3
实验报告
• 内容包括但不限于:逻辑设计(数据通路和状态 图)、核心代码、仿真/下载结果、结果分析、实 验总结、意见/建议等,附设计和仿真代码
• 实验检查后一周内提交实验报告
2019春_计算机组成原理实验_CS-USTC
2
实验要求和检查
• 完成1和3的的逻辑设计、仿真和下载测试
– 逻辑设计采用模块化设计 – 仿真3时忽略display – 下载测试时,时钟采用板载100MHz时钟,其他输入
由拨动开关和按钮开关设置,结果输出至LED指示灯 或7段数码管
• 查看1和2的电路性能和资源使用情况
rst
FIFO
16
display
4
out empty
- out, in:出/入队列数据
clk
full
- full, empty:队列空/满, 空/满时忽略出/入队操作
- display:8个数码管的控 制信号,显示队列状态
.
1. 2 3 2. 3
复位 数据1, 2, 3依次入队 列
数据1出队列
2019-3-28
– ftp://202.38.79.134/ 相应文件夹 – 文件名格式:Labn_学号_姓名.pdf (其中n为第几次
实验,不满足该格式的视为未提交实验报告)
• 严禁抄袭,否则作零分处理
2019-3-28
2019春_计算机组成原理实验_CS-USTC
4
The End
2019-3-28
2019春_计算机组成原理实验_CS-USTC
数字逻辑(白中英)课后习题答案
![数字逻辑(白中英)课后习题答案](https://img.taocdn.com/s3/m/429e271bb0717fd5370cdc1f.png)
第四章习题答案1.设计4个寄存器堆。
解:寄存器组2. 设计具有4个寄存器的队列。
解:输入数据输出数据3.设计具有4个寄存器的堆栈解:可用具有左移、右移的移位寄存器构成堆栈。
栈顶SR 1SR 2SR 3输入数据输出数据压入弹出4.SRAM 、DRAM 的区别解:DRAM 表示动态随机存取存储器,其基本存储单元是一个晶体管和一个电容器,是一种以电荷形式进行存储的半导体存储器,充满电荷的电容器代表逻辑“1”,“空”的电容器代表逻辑“0”。
数据存储在电容器中,电容存储的电荷一般是会慢慢泄漏的,因此内存需要不时地刷新。
电容需要电流进行充电,而电流充电的过程也是需要一定时间的,一般是0.2-0.18微秒(由于内存工作环境所限制,不可能无限制的提高电流的强度),在这个充电的过程中内存是不能被访问的。
DRAM 拥有更高的密度,常常用于PC 中的主存储器。
SRAM 是静态的,存储单元由4个晶体管和两个电阻器构成,只要供电它就会保持一个值,没有刷新周期,因此SRAM 比DRAM 要快。
SRAM 常常用于高速缓冲存储器,因为它有更高的速率;5. 为什么DRAM 采用行选通和列选通解:DRAM 存储器读/写周期时,在行选通信号RAS 有效下输入行地址,在列选通信号CAS 有效下输入列地址。
如果是读周期,此位组内容被读出;如果是写周期,将总线上数据写入此位组。
由于DRAM 需要不断刷新,最常用的是“只有行地址有效”的方法,按照这种方法,刷新时,是在RAS 有效下输入刷新地址,存储体的列地址无效,一次选中存储体中的一行进行刷新。
每当一个行地址信号RAS 有效选中某一行时,该行的所有存储体单元进行刷新。
6. 用ROM 实现二进制码到余3码转换 解: 真值表如下:8421码 余三码B3B2 B1 B0G3G2 G1G00 0 0 00 0 0 10 0 1 00 0 1 10 1 0 00 1 0 10 1 1 00 1 1 11 0 0 01 0 0 10 1 1 01 0 0 01 0 1 01 1 0 01 1 1 10 0 0 10 0 1 10 1 0 10 1 1 110 0最小项表达式为:G 3=∑)9,8,7,6,5( G 2=∑)9,4,3,2,1( G 1=∑)8,7,4,3,0( G 0=∑)8,6,4,2,0( 阵列图为:G 3G 2G 1GB 3B 2B 1B B 07. 用ROM 实现8位二进制码到8421码转换解:输入为8位二进制数,输出为3位BCD 码,12位二进制数,所以,所需ROM 的容量为:28*12=30728.ROM、EPROM和EEPROM的区别解:ROM 指的是“只读存储器”,即Read-Only Memory。
计算机设计与实践——MIPS基本指令
![计算机设计与实践——MIPS基本指令](https://img.taocdn.com/s3/m/b794bb6590c69ec3d5bb758c.png)
MIPS 基本指令和寻址方式:MIPS 是典型的RISC 处理器,采用32位定长指令字,操作码字段也是固定长度,没有专门的寻址方式字段,由指令格式确定各操作数的寻址方式。
MIPS 指令格式一般有三种格式: R-型指令格式 I-型指令格式 J-型指令格式R _Type 指指指指262116116316bit6bit5bit5bit5bit5bitOP : 操作码rs : 第一个源操作数寄存器rt : 第二个源操作数寄存器(单目原数据) rd : 结果寄存器 shamt :移位指令的位移量 func : 指令的具体操作类型特点:R-型指令是RR 型指令,其操作码OP 字段是特定的“000000”,具体操作类型由func字段给定。
例如:func=“100000”时,表示“加法”运算。
R[rd] ← R[rs] + R[rt]I _Type 指指指指2621163115特点:I-型指令是立即数型指令双目运算: R[rt] R[rs](OP )SignExt(imm16) Load 指令:Addr ← R[rs] + SignExt(imm16) 计算数据地址 (立即数要进行符号扩展) R[rt] ← M[Addr] 从存储器中取出数据,装入到寄存器中Store 指令:Addr ← R[rs] + SignExt(imm16) M[Addr] ← R[rt]J _Type 指令格式26316bit26bit25特点:J-型指令主要是无条件跳转指令,将当前PC 的高4位拼上26位立即数,后补两个“0”,作为跳转目标地址。
j L //goto L 指指指指指指指指指jal L //$ra 指PC+4;goto L 指指指指指指指指指R 型指令:定点运算: add / addu , sub / subu , sra , mult/multu , div/divu 逻辑运算: and / or / nor , sll / srl 比较分支: beq / bne / slt / sltu 跳转指令: jrI 型指令:定点运算: addi / addiu 逻辑运算: andi / ori 比较分支: slti / sltiu数据传送: lw / sw / lhu / sh / lbu / sb / luiJ 型指令: j / jal设计模块划分,教学安排1、MIPS格式指令系统设计2、指令存储器设计3、寄存器堆设计4、ALU设计——基本算术、逻辑单元的设计32位超前进位加法器的设计32位桶式移位寄存器的设计5、取指令部件的设计6、立即数处理单元设计7、单周期处理器设计——R型指令的数据通路设计I型指令的数据通路设计Load/Store指令的数据通路设计分支指令/转移指令的数据通路设计综合12条指令的完整数据通路设计8、ALU控制单元设计9、主控制单元的设计10、单周期处理器总体验证11、异常和中断处理及其电路实现12、带有异常和中断处理功能的处理器的设计设计示例1:指令存储器设计1、 指令存储器模块定义:指令存储器用于存放CPU 运算的程序指令和数据等,采用单端口存储器设计,设计最大为64个存储单元,每个存储单元数据宽度为32bit 。
杭电计算机组成原理寄存器堆设计实验
![杭电计算机组成原理寄存器堆设计实验](https://img.taocdn.com/s3/m/d8703f5aa31614791711cc7931b765ce05087ac7.png)
杭电计算机组成原理寄存器堆设计实验计算机组成原理是计算机科学与技术的基础课程之一,它涉及到计算机的基本组成部分和原理。
在这门课程中,学生通常需要进行一系列的实验来加深对计算机组成原理的理解和应用。
其中之一是关于寄存器堆的设计实验。
寄存器堆是计算机中重要的组成部分之一,它用于存储、读取和写入数据。
在计算机中,数据通常被存储在寄存器中,然后进行各种操作。
因此,设计一个高效可靠的寄存器堆对于计算机的性能至关重要。
根据实验要求,我们需要设计一个8位的寄存器堆,并实现读取、写入和清零等操作。
以下是针对该实验的设计思路和实施步骤。
首先,我们需要确定寄存器堆的结构。
由于该寄存器堆为8位宽度,我们选择使用一个8x8的存储单元阵列。
每个存储单元都可以存储一个8位的数据。
整个寄存器堆由8个存储单元组成,每个存储单元对应一个地址,即0~7接下来,我们需要设计寄存器堆的读写电路。
对于读操作,我们需要通过地址线来选择要读取的存储单元,并将其输出到数据线。
对于写操作,我们同样需要通过地址线来选择要写入的存储单元,并将数据线上的数据写入该存储单元。
为了实现这些操作,我们需要使用多路选择器和数据解码器。
在设计中,我们还需要考虑到时钟信号的输入,以确保读写操作在时钟的上升沿或下降沿进行。
此外,我们还需要添加清零功能,以便将寄存器堆的值重置为零。
为实现清零功能,我们可以将一个额外的输入线与所有存储单元的清零输入连接。
在实施阶段,我们需要使用Verilog或其他硬件描述语言来实现设计。
在代码中,我们首先声明一个8位宽的存储单元阵列作为寄存器堆的基本组成部分。
然后,我们定义读写电路,包括地址线、数据线、多路选择器和数据解码器。
最后,我们添加时钟信号和清零功能。
在完成设计后,我们可以通过仿真工具进行验证。
通过输入不同的数据和地址,观察输出结果是否符合预期。
如果存在问题,我们可以进行调试并进行必要的修改。
一旦仿真结果正确无误,我们就可以开始进行硬件实验了。
数字逻辑课后答案 第四章
![数字逻辑课后答案 第四章](https://img.taocdn.com/s3/m/6ff5036d25c52cc58bd6be88.png)
第四章 习题答案1.设计4个寄存器堆。
解:2. 设计具有4个寄存器的队列。
解:3.设计具有4个寄存器的堆栈解:可用具有左移、右移的移位寄存器构成堆栈。
寄存器组输入数据输出数据4.SRAM 、DRAM 的区别解:DRAM 表示动态随机存取存储器,其基本存储单元是一个晶体管和一个电容器,是一种以电荷形式进行存储的半导体存储器,充满电荷的电容器代表逻辑“1”,“空”的电容器代表逻辑“0”。
数据存储在电容器中,电容存储的电荷一般是会慢慢泄漏的,因此内存需要不时地刷新。
电容需要电流进行充电,而电流充电的过程也是需要一定时间的,一般是0.2-0.18微秒(由于内存工作环境所限制,不可能无限制的提高电流的强度),在这个充电的过程中内存是不能被访问的。
DRAM 拥有更高的密度,常常用于PC 中的主存储器。
SRAM 是静态的,存储单元由4个晶体管和两个电阻器构成,只要供电它就会保持一个值,没有刷新周期,因此SRAM 比DRAM 要快。
SRAM 常常用于高速缓冲存储器,因为它有更高的速率;5. 为什么DRAM 采用行选通和列选通解:DRAM 存储器读/写周期时,在行选通信号RAS 有效下输入行地址,在列选通信号CAS 有效下输入列地址。
如果是读周期,此位组内容被读出;如果是写周期,将总线上数据写入此位组。
由于DRAM 需要不断刷新,最常用的是“只有行地址有效”的方法,按照这种方法,刷新时,是在RAS 有效下输入刷新地址,存储体的列地址无效,一次选中存储体中的一行进行刷新。
每当一个行地址信号RAS 有效选中某一行时,该行的所有存储体单元进行刷新。
6. 用ROM 实现二进制码到余3码转换 解: 真值表如下:8421码 余三码B B BG G G栈顶SR 1SR 2SR 3输入数据输出数据压入弹出3232BG0 0 00 0 0 10 0 1 00 0 1 10 1 0 00 1 0 10 1 1 00 1 1 11 0 0 01 0 0 10 0 110 1 0 00 1 0 10 1 1 00 1 1 11 0 0 01 0 0 11 0 1 01 0 1 11 1 0 0最小项表达式为: G=G=G=G=阵列图为:7. 用ROM 实现8位二进制码到8421码转换10103∑)9,8,7,6,5(2∑)9,4,3,2,1(1∑)8,7,4,3,0(0∑)8,6,4,2,0(G 3G 2G 1G 0B 3B 2B 1B B 0解:输入为8位二进制数,输出为3位BCD码,12位二进制数,所以,所需8ROM的容量为:2*12=30728.ROM、EPROM和EEPROM的区别解:ROM 指的是“只读存储器”,即Read-Only Memory。
寄存器堆的设计
![寄存器堆的设计](https://img.taocdn.com/s3/m/aebf21ceac51f01dc281e53a580216fc700a53a1.png)
寄存器堆设计1、功能概述:MIPS指令格式中的寄存器号是5bits,指令可以访问25=32个32位的寄存器。
这样的一堆寄存器“堆在一起”构成一个寄存器堆(Register File)。
2、接口说明:寄存器堆模块接口信号说明表脉冲regfile_clk,复位端regfiles_rst,写使能端regfiles_Wen,写地址regfile_Waddr,写数据regfiles_Wdata,读地址一regfiles_Raddr_1,读地址二regfiles_Raddr_2,读数据一regfiles_Rdata_1,读数据二regfiles_Rdata_2;设计思路:1、复位处理是利用标志位flag实现的,当复位时,flag=0;利用i来计数,当i<31时,flag都等于0;直到i=32,复位完成,flag=1,这时,才可以进行写操作。
2、当复位时,需要32个脉冲才能将寄存器全部复位。
复位未完成,flag一直等于0。
若复位未完成时,进行写操作,这时,并不能写进去,便出错了。
所以,进行32分频,当寄存器可以写入时,复位已完成。
3、设计电路源代码//----32个32位寄存器堆module regfile(input regfile_clk, //脉冲input regfile_rst, //复位端input regfile_Wen, //写使能端input [4:0] regfile_Raddr_1,//读地址一input [4:0] regfile_Raddr_2,//读地址二input [4:0] regfile_Waddr, //写地址input [31:0] regfile_Wdata, //写数据output [31:0] regfile_Rdata_1,//读数据一output [31:0] regfile_Rdata_2//读数据二);//----------------------------------reg [31:0]regfiles[0:31]; //实现寄存功能reg [4:0] i; //实现flag的变换reg flag; //实现复位的标志reg regfile_clk_1; //实现写数据的脉冲reg [4:0]count;//---32分频处理always@(posedge regfile_c lk or posedge regfile_rst) beginif(regfile_rst)begincount<=5'd0;regfile_clk_1<=1'b0;endelse if(count<5'd16)begincount<=count+1'b1;endelsebegincount<=5'd0;regfile_clk_1<=~regfile_clk_1;endend//---复位处理always@(posedge regfile_c lk or posedge regfile_rst) beginif(regfile_rst)begini<=5'd0;flag<=1'b0;endelse if(i<5'b11111)begini<=i+1'b1;flag<=1'b0;endelseflag<=1'b1;end//---写操作always@(posedge regfile_c lk_1)beginif(~flag)regfiles[i]<=32'd0;elsebeginif(regfile_Wen&&(regfile_Waddr!=5'd0)) //写使能端为一,写地址不为零beginregfiles[regfile_Waddr]<=regfile_Wdata; //写入endendend//---读操作assign regfile_Rdata_1=(regfile_Raddr_1==5'd0)?32'd0:regfiles[regfile_Raddr_1];assign regfile_Rdata_2=(regfile_Raddr_2==5'd0)?32'd0:regfiles[regfile_Raddr_2];////----------------------------------------endmodule4、设计电路仿真所设计的指令存储器模块电路,采用ISE仿真器工具进行了设计仿真验证,验证结果表明存储器功能以及接口时序完全正确,如下是仿真验证的波形图。
设计示例2寄存器堆设计
![设计示例2寄存器堆设计](https://img.taocdn.com/s3/m/a1c930760508763230121233.png)
设计示例2:寄存器堆设计1、 功能概述:MIPS 指令格式中的寄存器号是5bits ,指令可以访问25=32个32位的寄存器。
这样的一堆寄存器“堆在一起”构成一个寄存器堆(Register File )。
模块框图如图1所示:Regfile图1 模块框图2、 结构框图:3、 接口说明:表1: 寄存器堆模块接口信号说明表clk we wdata Valid Validwaddrrst_n图2 寄存器堆写时序框图4、设计电路源代码//功能描述风格寄存器堆的设计module regfile(input clk,input rst_n,//写端口input we, //写使能input[4:0] waddr, //写寄存器下标input[31:0] wdata, //待写入寄存器堆的数据//读端口1input[4:0]raddr1, //读端口1寄存器下标output[31:0] rdata1,//从端口1读出的寄存器堆的数据//读端口2input[4:0]raddr2, //读端口2寄存器下标output[31:0] rdata2 //从端口2读出的寄存器堆的数据);reg[31:0] regs[0:31]; //32个32位寄存器堆//Write operationalways @ (posedge clk or negedge rst_n) beginif(!rst_n) begin:reset_all_registers //将32个寄存器复位为0.integer i;for(i=0;i<32;i=i+1)regs[i] = 32'd0;endelse begin//写寄存器堆有效时,更新寄存器堆中某个寄存器的数据if((we == 1'b1) && (waddr != 5'h0)) beginregs[waddr] <= wdata;endendend//Read port1 operationassign rdata1 = (raddr1 == 5'd0) ? 32'd0 : regs[raddr1];//Read port2 operationassign rdata2 = (raddr2 == 5'd0) ? 32'd0 : regs[raddr2];endmodule//风格2module regfile2(input clk,input rst_n,//写端口input we,input[4:0]waddr,input[31:0] wdata,//读端口1input[4:0]raddr1,output reg[31:0] rdata1,//读端口2input[4:0]raddr2,output reg[31:0] rdata2);reg[31:0] reg0,reg1,reg2,reg3; //Write operationalways @ (posedge clk) beginif(!rst_n) beginreg0 <= 32'd0;reg1 <= 32'd0;reg2 <= 32'd0;reg3 <= 32'd0;endelse beginif(we == 1'b1) begincase(waddr)5'd0: reg0 = wdata;5'd1: reg1 = wdata;5'd2: reg2 = wdata;5'd3: reg3 = wdata;default: ;endcaseendendend//Read port1 operationalways @ (*) begincase(raddr1)5'd0: rdata1 = 32'd0;5'd1: rdata1 = reg1;5'd2: rdata1 = reg2;5'd3: rdata1 = reg3;default: rdata1 = 32'd0;endcaseend//Read port2 operationalways @ (*) begincase(raddr2)5'd0: rdata2 = 32'd0;5'd1: rdata2 = reg1;5'd2: rdata2 = reg2;5'd3: rdata2 = reg3;default: rdata2 = 32'd0;endcaseendendmodule5、设计电路仿真所设计的指令存储器模块电路,采用Modelsim10.1a仿真器工具进行了设计仿真验证,验证结果表明存储器功能以及接口时序完全正确,如下是仿真验证的波形图。
寄存器组的设计与实现
![寄存器组的设计与实现](https://img.taocdn.com/s3/m/45a253b17d1cfad6195f312b3169a4517723e5c3.png)
寄存器组的设计与实现寄存器组是计算机中的重要组成部分,用于存储和操作数据。
设计和实现一个合适的寄存器组对计算机的性能和功能起着至关重要的作用。
下面将详细介绍寄存器组的设计与实现。
首先,寄存器组的设计应满足以下几个关键要求:1.容量大小:寄存器组的容量应根据计算机的需求来确定,通常以位为单位进行衡量。
较大的容量可以提高计算机的运算能力,但也会增加成本和功耗。
2.位宽度:位宽度指寄存器组中每个寄存器可以存储的位数。
根据计算机的需求,可以选择不同的位宽度,常见的有8位、16位、32位和64位。
较大的位宽度可以提高数据处理速度,但也会增加硬件的复杂性。
3.读写速度:寄存器组应具有足够快的读和写速度,以确保数据的实时性和准确性。
这取决于寄存器组的存储器技术和访问方式。
接下来是寄存器组的实现方式。
常见的寄存器组实现方式有以下几种:1.存储在寄存器文件中:寄存器文件是一种硬件电路,用于存储和操作寄存器。
寄存器文件可以使用静态随机存取存储器(SRAM)或动态随机存取存储器(DRAM)来实现。
它包含多个寄存器,并且可以同时读取和写入多个寄存器。
2.分段寄存器组:在一些计算机架构中,寄存器组被划分为多个段,每个段用于存储不同类型的数据,例如程序计数器、指令寄存器、数据寄存器等。
这种分段寄存器组可以提高计算机的性能和功能。
3.流水线寄存器组:流水线是一种计算机指令执行方式,其中指令被分为多个流水线级别,并依次在各级别上执行。
为了实现流水线执行,需要使用流水线寄存器组来存储每个级别的数据和状态。
流水线寄存器组能够提高计算机的指令执行速度和吞吐量。
此外,寄存器组的实现还要考虑以下几个方面:1.传输方式:寄存器组可以使用并行传输方式或串行传输方式进行数据的读写。
并行传输方式可以提高数据传输速度,但需要更多的硬件资源。
串行传输方式可以减少硬件成本,但速度较慢。
2.控制逻辑:寄存器组的读写操作需要通过控制逻辑进行控制。
控制逻辑可以使用组合逻辑电路或时序逻辑电路来实现。
一种6读2写多端口寄存器堆的全定制实现
![一种6读2写多端口寄存器堆的全定制实现](https://img.taocdn.com/s3/m/216184cfa417866fb94a8e02.png)
一种6读2写多端口寄存器堆的全定制实现张轩;李兆麟【摘要】采用全定制设计方法实现了一种6读2写的32′32位的多端口寄存器堆,包括结构设计、电路设计、版图设计、仿真验证以及建模建库.该多端口寄存器堆的读写端口互相独立,在一个时钟周期内,能够同时读出6个32位数据,并写入2个32位数据.在电路实现上,采用高速SCL结构的地址译码和分组字线的方法来减少读写延迟.采用了0.18μm 6层金属P阱CMOS工艺来实现版图设计,通过了版图验证和后端仿真.【期刊名称】《计算机工程》【年(卷),期】2007(033)020【总页数】3页(P248-250)【关键词】多端口寄存器堆;高速SCL结构;全定制设计;自顶向下的设计流程【作者】张轩;李兆麟【作者单位】清华大学信息科学技术学院,CPU & SoC实验室,北京,100084;清华大学信息科学技术学院,CPU & SoC实验室,北京,100084【正文语种】中文【中图分类】工业技术第 33 卷Vol.33 第 20期No.20 计算机工程Computer Engineering 2007 年 10 月October 2007·工程应用技术与实现·文章编号: 1000-3428(2007)20-0248-03文献标识码: A中图分类号: TN47一种 6 读 2 写多端口寄存器堆的全定制实现张轩,李兆●(清华大学信息科学技术学院, CPU&SoC 实验室,北京 100084)摘要:采用全定制设计方法实现了一种 6 读 2 写的 32x32 位的多端口寄存器堆,包括结构设计、电路设计、版图设计、仿真验证以及建模建库。
该多端口寄存器堆的读写端口互相独立,在一个时钟周期内,能够同时读出 6个 32 位数据,并写入 2 个 32 位数据。
在电路实现上,采用高速 SCL 结构的地址译码和分组字线的方法来减少读写延迟。
采用了 0.18Um6层金属 P 阱 CMOS 工艺来实现版图设计,通过了版图验证和后端仿真。
多端口寄存器堆的低功耗设计方法
![多端口寄存器堆的低功耗设计方法](https://img.taocdn.com/s3/m/78e1c42415791711cc7931b765ce050877327574.png)
多端口寄存器堆的低功耗设计方法0 引言寄存器堆是构成微处理器的重要部件,缓存和传输操作数是它的基本作用,其性能优劣将直接影响处理器的处理能力。
随着处理器并行处理能力的加强,寄存器堆的端口越来越多,端口的增加不但增加了功耗,也加大了读写延时,限制了处理器时钟频率的提高,成为高性能微处理器的片上存储瓶颈。
高速和低功耗是多端口寄存器堆的设计目标,但是两者之间相互约束。
在Motorola的M.CORE处理器中,寄存器堆的功耗占整个芯片的16%,在数据通路中的比例更是高达42%。
有研究表明,寄存器堆的功耗达到整个处理器芯片功耗的25%。
因此,高速低功耗的多端口寄存器堆的设计成为未来存储器设计中极具挑战性的工作。
1 寄存器堆的功耗组成1.1 寄存器堆的总体结构目前寄存器堆所采用的基本组成单元是6T SRAM。
寄存器堆在电路结构上,可分为四个部分。
第一是由存储单元构成的存储阵列;第二是由地址缓冲器、译码器、字线及其驱动器构成的地址路径;第三是由数据缓冲器、读写放大器、位线及其预充电路构成的数据路径;第四是读写控制逻辑。
如图1所示。
1.2 多端口寄存器堆结构多端口的存储单元一般每个端口都有自己的字线和位线,从而保证各个端口能够同时独立工作,以满足指令级并行的微处理器工作要求。
但是这同时也导致了寄存器堆功耗的迅速提高。
多端口读写位线一般有差分式和单端式两种,差分式读写以更高的数据准确性和读写速度应用于多数的多端口设计。
其结构如图2所示。
1.3 多端口寄存器堆的功耗组成1.3.1 基本单元SRAM基本单元SRAM的功耗主要由三个部分组成。
一是动态功耗,即电容充放电所消耗的功耗。
二是短路功耗,即电源和地导通时所消耗的功耗。
三是MOS管泄漏电流所引起的静态功耗。
在三种功耗中动态功耗所占比重最大,而SRAM中位线连接许多存储体单元,其电容负载很大,位线充放电所引起的动态功耗就很大,占到总体动态功耗的80%,所以优化位线动态功耗对整个SRAM功耗降低影响很大。
杭电计组实验4-寄存器堆设计实验
![杭电计组实验4-寄存器堆设计实验](https://img.taocdn.com/s3/m/23bc8170856a561253d36f31.png)
杭电计组实验4-寄存器堆设计实验实验报告2018 年 5 月12 日成绩:一、实验程序源代码1.寄存器堆模块代码:moduleRegister_file(R_Addr_A,R_Addr_B,W_Addr,Write_Reg,W_Data,Clk,Reset,R_Data_A,R_Data_B); input [4:0]R_Addr_A;input [4:0]R_Addr_B;input [4:0]W_Addr;input Write_Reg;input [31:0]W_Data;input Clk;input Reset;output [31:0]R_Data_A;output [31:0]R_Data_B;reg [31:0]REG_Files[0:31];reg [5:0]i;initial//仿真过程中的初始化beginfor(i=0;i<=31;i=i+1)REG_Files[i]=0;endassign R_Data_A=REG_Files[R_Addr_A];assign R_Data_B=REG_Files[R_Addr_B];2'b01:LED=R_Data_A[15:8];2'b10:LED=R_Data_A[23:16];2'b11:LED=R_Data_A[31:24];endcaseendelsebeginB=Addr;case(C1)2'b00:LED=R_Data_B[7:0];2'b01:LED=R_Data_B[15:8];2'b10:LED=R_Data_B[23:16];2'b11:LED=R_Data_B[31:24];endcaseendendelse//写操作begincase(C1)2'b00:W_Data=32'h0000_0003;2'b01:W_Data=32'h0000_0607;2'b10:W_Data=32'hFFFF_FFFF;2'b11:W_Data=32'h1111_1234;endcaseendendendmodule3.测试代码module test;// Inputsreg [4:0] R_Addr_A;reg [4:0] R_Addr_B;reg [4:0] W_Addr;reg Write_Reg;reg [31:0] W_Data;reg Clk;reg Reset;// Outputswire [31:0] R_Data_A;wire [31:0] R_Data_B;// Instantiate the Unit Under Test (UUT) Register_file uut (.R_Addr_A(R_Addr_A),.R_Addr_B(R_Addr_B),.W_Addr(W_Addr),.Write_Reg(Write_Reg),.W_Data(W_Data),.Clk(Clk),.Reset(Reset),.R_Data_A(R_Data_A),.R_Data_B(R_Data_B));initial begin// Initialize InputsR_Addr_A = 0;R_Addr_B = 0;W_Addr = 0;Write_Reg = 0;W_Data = 0;Clk = 0;Reset = 0;// Wait 100 ns for global reset to finish #100;// Add stimulus here#100;R_Addr_A = 0;R_Addr_B = 0;W_Addr = 5'b00001;Write_Reg = 1;W_Data = 32'h1111_1111;Clk = 1;Reset = 0;#100;R_Addr_A = 0;R_Addr_B = 0;W_Addr = 5'b00001; Write_Reg = 1;W_Data = 32'h1111_1111; Clk = 0;Reset = 0;#100;R_Addr_A = 0;R_Addr_B = 0;W_Addr = 5'b00010; Write_Reg = 1;W_Data = 32'h2222_2222; Clk = 1;Reset = 0;#100;R_Addr_A = 5'b00001;R_Addr_B = 5'b00010;W_Addr = 0;Write_Reg = 0;W_Data = 0;Clk = 0;Reset = 0;#100;R_Addr_A = 5'b00001;R_Addr_B = 5'b00010;W_Addr = 0;Write_Reg = 0;W_Data = 0;Clk = 0;Reset = 1;endendmodule二、仿真波形三、电路图顶层电路模块顶层电路内部结构:四、引脚配置(约束文件)NET "Clk" LOC = C9;NET "Reset" LOC = D9;NET "Write_Reg" LOC = T5;NET "C2" LOC = C4;# PlanAhead Generated physical constraintsNET "LED[7]" LOC = T11;NET "LED[6]" LOC = R11;NET "LED[4]" LOC = M11;NET "LED[3]" LOC = V15;NET "LED[1]" LOC = V16;NET "LED[0]" LOC = U16;NET "LED[2]" LOC = U15;NET "LED[5]" LOC = N11;NET "Addr[0]" LOC = T10;NET "Addr[2]" LOC = V9;NET "Addr[3]" LOC = M8;NET "Addr[4]" LOC = N8;NET "C1[0]" LOC = U8;NET "C1[1]" LOC = V8;NET "Addr[1]" LOC = T9;五、思考与探索(1)实验四实验结果记录表寄存器地址写入数据读出数据$1 32'h0000_000332'h0000_0003$2 32'h0000_0607 32'h0000_0607$3 32'hFFFF_FFFF32'hFFFF_FFFF$4 32'h1111_123432'h1111_1234$5 32'h0000_000332'h0000_0003$6 32'h0000_060732'h0000_0607$7 32'hFFFF_FFFF 32'hFFFF_FFFF$8 32'h1111_123432'h1111_1234。
寄存器及寄存器堆设计
![寄存器及寄存器堆设计](https://img.taocdn.com/s3/m/daf32195dd88d0d233d46a1c.png)
input wire [3:0] dp_in, // 4 decimal points output reg [3:0] an, // enable 1‐out‐of‐4 asserted low output reg [7:0] sseg // led segments
);
localparam N = 18; //refreshing rate around 800 Hz (50 MHz/2^16)
3、锁存器
• 锁存器由多个一位锁存器/触发器并联构成
– 一般采用电平控制锁存: – 高电平时置入数据 – 低电平时锁存数据,并指示数据稳定 – 带使能端的RS触发器实现的锁存器
module lock(lock, D, clear, Q); //... assign cr = {8{clear}} | (~D); assign Din = D & (~{8{clear}}); assign lock1 = lock | clear; RS_CE R0(lock1, cr[0], Din[0], Q[0], Qbar[0]), R1(lock1, cr[1], Din[1], Q[1], Qbar[1]), R2(lock1, cr[2], Din[2], Q[2], Qbar[2]), R3(lock1, cr[3], Din[3], Q[3], Qbar[3]), R4(lock1, cr[4], Din[4], Q[4], Qbar[4]), R5(lock1, cr[5], Din[5], Q[5], Qbar[5]), R6(lock1, cr[6], Din[6], Q[6], Qbar[6]), R7(lock1, cr[7], Din[7], Q[7], Qbar[7]); endmodule
寄存器堆的设计
![寄存器堆的设计](https://img.taocdn.com/s3/m/f5a2b8943968011ca200913f.png)
寄存器堆的设计————————————————————————————————作者: ————————————————————————————————日期:寄存器堆设计1、功能概述:MIPS指令格式中的寄存器号是5bits,指令可以访问25=32个32位的寄存器。
这样的一堆寄存器“堆在一起”构成一个寄存器堆(Register File)。
2、接口说明:寄存器堆模块接口信号说明表脉冲reg,复位端reg,写使能端reg,写地址reg,写数据reg,读地址一reg,读地址二reg,读数据一reg,读数据二reg;设计思路:1、复位处理是利用标志位flag实现的,当复位时,flag=0;利用i来计数,当i<31时,flag都等于0;直到i=32,复位完成,flag=1,这时,才可以进行写操作。
2、当复位时,需要32个脉冲才能将寄存器全部复位。
复位未完成,flag一直等于0。
若复位未完成时,进行写操作,这时,并不能写进去,便出错了。
所以,进行32分频,当寄存器可以写入时,复位已完成。
3、设计电路源代码//----32个32位寄存器堆moduleregfile(inputreg, //脉冲input reg, //复位端inputreg,//写使能端input[4:0] reg读地址一input[4:0]reg读地址二input[4:0] reg,//写地址input[31:0]reg,//写数据output[31:0] reg读数据一output [31:0] reg读数据二);//----------------------------------reg[31:0]regfiles[0:31]; //实现寄存功能reg [4:0]i;//实现flag的变换reg flag;//实现复位的标志regreg; //实现写数据的脉冲reg [4:0]count;//---32分频处理always@(posedgereg or posedge reg)beginif(reg)begincount<=5'd0;ﻩreg<=1'b0;ﻩendﻩelse if(count<5'd16)ﻩbeginﻩcount<=count+1'b1;endelseﻩbeginﻩcount<=5'd0;ﻩreg<=~reg;endend//---复位处理always@(posedge reg orposedge reg)beginif(reg)ﻩbegini<=5'd0;ﻩflag<=1'b0;ﻩendﻩelseif(i<5'b11111)beginﻩi<=i+1'b1;flag<=1'b0;endﻩelseflag<=1'b1;ﻩend//---写操作always@(posedgereg)beginif(~flag)ﻩregfiles[i]<=32'd0;elsebeginif(reg(reg'd0)) //写使能端为一,写地址不为零ﻩbeginﻩﻩregfiles[reg]<=reg;//写入ﻩﻩﻩendﻩﻩendend//---读操作assign reg(reg'd0)?32'd0:regfiles[reg];assign reg(reg'd0)?32'd0:regfiles[reg];////----------------------------------------endmodule4、设计电路仿真所设计的指令存储器模块电路,采用ISE仿真器工具进行了设计仿真验证,验证结果表明存储器功能以及接口时序完全正确,如下是仿真验证的波形图。
寄存器原理结构
![寄存器原理结构](https://img.taocdn.com/s3/m/664daa58974bcf84b9d528ea81c758f5f61f2911.png)
寄存器原理结构寄存器是计算机中一种重要的存储设备,用于存储和传输数据。
它由多个存储单元组成,每个存储单元能够存储一个固定大小的数据。
寄存器的结构是计算机体系结构设计中的关键要素之一。
一、寄存器的基本原理寄存器是一种高速存储设备,用于存储指令和数据。
它能够快速存取数据,并能够在需要时将数据传送到其他部件中。
寄存器的基本原理是通过电子元件来实现数据的存储和传输。
常见的寄存器有通用寄存器、程序计数器、状态寄存器等。
二、寄存器的结构1. 存储单元:寄存器由多个存储单元组成,每个存储单元能够存储一个固定大小的数据。
存储单元通常由触发器或锁存器实现,能够存储二进制数据。
存储单元之间通过数据线相连,实现数据的传输。
2. 控制电路:控制电路用于控制寄存器的读写操作。
它包括时钟信号发生器、使能信号控制器等。
时钟信号发生器产生时钟信号,使得寄存器的读写操作能够按照时序进行。
使能信号控制器用于控制寄存器的使能信号,使得数据能够正确地写入和读出。
3. 数据线:数据线用于传输数据。
在寄存器中,数据线连接各个存储单元和其他部件,实现数据的输入和输出。
数据线的宽度决定了寄存器能够存储的数据的位数。
4. 输入端口和输出端口:寄存器的输入端口用于接收数据的输入信号,输出端口用于输出数据。
输入端口和输出端口通过数据线与存储单元相连,实现数据的输入和输出。
三、寄存器的工作原理寄存器的工作原理是通过时钟信号和使能信号控制数据的读写。
寄存器的读操作是在时钟上升沿或下降沿进行的,写操作是在时钟上升沿或下降沿之后进行的。
当使能信号为高电平时,寄存器能够进行读写操作,当使能信号为低电平时,寄存器处于禁止读写状态。
寄存器的读操作是将指定的存储单元中的数据传送到输出端口,输出端口再将数据输出到其他部件中。
寄存器的写操作是将输入端口的数据写入到指定的存储单元中。
四、寄存器的应用1. 数据传输:寄存器能够将数据从一个部件传输到另一个部件,实现数据的传递和共享。
《计算机组成原理》实验报告——寄存器堆
![《计算机组成原理》实验报告——寄存器堆](https://img.taocdn.com/s3/m/fa2fe008aeaad1f347933fe7.png)
南通大学信息科学技术学院《计算机组成实验》实验报告实验寄存器堆的设计与实现一、实验目的1.熟悉Vivado软件的使用方法。
2.熟悉寄存器堆的功能。
3.掌握自顶而下的硬件模块设计方法。
4.掌握电路仿真测试方法,掌握仿真激励文件的编写,掌握仿真输出的分析方法。
二、实验任务设计一个寄存器堆,满足两路输出一路输入的功能,并完成仿真测试。
三、实验预习(1)实验电路原理及信号说明寄存器堆(REGFILE)是CPU组成的重要存储部件,也是数据通路中的重要部件,其主要功能是对数据进行存储。
在本实验中将为REGFILE构建32×32的寄存器组,即共有32个寄存器,每个寄存器的位宽都是32位。
32×32的REGFILE逻辑结构如图所示:具体设计如下:通过带有32个带使能端的D触发器实现数据的存储,5-32译码器实现地址与存储单元的连接选择,32位32选1选择器来实现输出。
(2)实验电路设计顶层文件:module REGFILE(Ra,Rb,D,Wr,We,Clk,Clrn,Qa,Qb);input [4:0]Ra,Rb,Wr;input [31:0]D;input We,Clk,Clrn;output [31:0]Qa,Qb;wire [31:0]Y;wire[31:0]Q31,Q30,Q29,Q28,Q27,Q26,Q25,Q24,Q23,Q22,Q21,Q20,Q19,Q18,Q17,Q16,Q15,Q14,Q13,Q12,Q11,Q 10,Q9,Q8,Q7,Q6,Q5,Q4,Q3,Q2,Q1,Q0;DEC5T32E dec(Wr,We,Y);REG32reg32(D,Y,Clk,Clrn,Q31,Q30,Q29,Q28,Q27,Q26,Q25,Q24,Q23,Q22,Q21,Q20,Q19,Q18,Q17,Q16,Q15,Q14,Q 13,Q12,Q11,Q10,Q9,Q8,Q7,Q6,Q5,Q4,Q3,Q2,Q1,Q0);MUX32X32select1(Q31,Q30,Q29,Q28,Q27,Q26,Q25,Q24,Q23,Q22,Q21,Q20,Q19,Q18,Q17,Q16,Q15,Q14,Q13,Q12,Q11 ,Q10,Q9,Q8,Q7,Q6,Q5,Q4,Q3,Q2,Q1,Q0,Ra,Qa);MUX32X32select2(Q31,Q30,Q29,Q28,Q27,Q26,Q25,Q24,Q23,Q22,Q21,Q20,Q19,Q18,Q17,Q16,Q15,Q14,Q13,Q12,Q11 ,Q10,Q9,Q8,Q7,Q6,Q5,Q4,Q3,Q2,Q1,Q0,Rb,Qb);Endmodule5-32地址译码器:module DEC5T32E(I,En,Y);input [4:0] I;input En;output [31:0] Y;reg [31:0] Y;always@(En or I)beginif(En)begincase(I)5'b00000:Y=32'b00000000000000000000000000000001;5'b00001:Y=32'b00000000000000000000000000000010;5'b00010:Y=32'b00000000000000000000000000000100;5'b00011:Y=32'b00000000000000000000000000001000;5'b00100:Y=32'b00000000000000000000000000010000;5'b00101:Y=32'b00000000000000000000000000100000;5'b00110:Y=32'b00000000000000000000000001000000;5'b00111:Y=32'b00000000000000000000000010000000;5'b01000:Y=32'b00000000000000000000000100000000;5'b01001:Y=32'b00000000000000000000001000000000;5'b01010:Y=32'b00000000000000000000010000000000;5'b01011:Y=32'b00000000000000000000100000000000;5'b01100:Y=32'b00000000000000000001000000000000;5'b01101:Y=32'b00000000000000000010000000000000;5'b01110:Y=32'b00000000000000000100000000000000;5'b01111:Y=32'b00000000000000001000000000000000;5'b10000:Y=32'b00000000000000010000000000000000;5'b10001:Y=32'b00000000000000100000000000000000;5'b10010:Y=32'b00000000000001000000000000000000;5'b10011:Y=32'b00000000000010000000000000000000;5'b10100:Y=32'b00000000000100000000000000000000;5'b10101:Y=32'b00000000001000000000000000000000;5'b10110:Y=32'b00000000010000000000000000000000;5'b10111:Y=32'b00000000100000000000000000000000;5'b11000:Y=32'b00000001000000000000000000000000;5'b11001:Y=32'b00000010000000000000000000000000;5'b11010:Y=32'b00000100000000000000000000000000;5'b11011:Y=32'b00001000000000000000000000000000;5'b11100:Y=32'b00010000000000000000000000000000;5'b11101:Y=32'b00100000000000000000000000000000;5'b11110:Y=32'b01000000000000000000000000000000;5'b11111:Y=32'b10000000000000000000000000000000;endcaseendelseY=32'b00000000000000000000000000000000;endendmodule32位寄存器moduleREG32(D,En,Clk,Clrn,Q31,Q30,Q29,Q28,Q27,Q26,Q25,Q24,Q23,Q22,Q21,Q20,Q19,Q18,Q17,Q16,Q15,Q14,Q1 3,Q12,Q11,Q10,Q9,Q8,Q7,Q6,Q5,Q4,Q3,Q2,Q1,Q0);input[31:0]D,En;input Clk,Clrn;output[31:0]Q31,Q30,Q29,Q28,Q27,Q26,Q25,Q24,Q23,Q22,Q21,Q20,Q19,Q18,Q17,Q16,Q15,Q14,Q13,Q12,Q11 ,Q10,Q9,Q8,Q7,Q6,Q5,Q4,Q3,Q2,Q1,Q0;wire[31:0]Qn31,Qn30,Qn29,Qn28,Qn27,Qn26,Qn25,Qn24,Qn23,Qn22,Qn21,Qn20,Qn19,Qn18,Qn17,Qn16,Qn15,Qn 14,Qn13,Qn12,Qn11,Qn10,Qn9,Qn8,Qn7,Qn6,Qn5,Qn4,Qn3,Qn2,Qn1,Qn0;D_FFEC32 q31(D,Clk,En[31],Clrn,Q31,Qn31);D_FFEC32 q30(D,Clk,En[30],Clrn,Q30,Qn30);D_FFEC32 q29(D,Clk,En[29],Clrn,Q29,Qn29);D_FFEC32 q28(D,Clk,En[28],Clrn,Q28,Qn28);D_FFEC32 q27(D,Clk,En[27],Clrn,Q27,Qn27);D_FFEC32 q26(D,Clk,En[26],Clrn,Q26,Qn26);D_FFEC32 q25(D,Clk,En[25],Clrn,Q25,Qn25);D_FFEC32 q24(D,Clk,En[24],Clrn,Q24,Qn24);D_FFEC32 q23(D,Clk,En[23],Clrn,Q23,Qn23);D_FFEC32 q22(D,Clk,En[22],Clrn,Q22,Qn22);D_FFEC32 q21(D,Clk,En[21],Clrn,Q21,Qn21);D_FFEC32 q20(D,Clk,En[20],Clrn,Q20,Qn20);D_FFEC32 q19(D,Clk,En[19],Clrn,Q19,Qn19);D_FFEC32 q18(D,Clk,En[18],Clrn,Q18,Qn18);D_FFEC32 q17(D,Clk,En[17],Clrn,Q17,Qn17);D_FFEC32 q16(D,Clk,En[16],Clrn,Q16,Qn16);D_FFEC32 q15(D,Clk,En[15],Clrn,Q15,Qn15);D_FFEC32 q14(D,Clk,En[14],Clrn,Q14,Qn14);D_FFEC32 q13(D,Clk,En[13],Clrn,Q13,Qn13);D_FFEC32 q12(D,Clk,En[12],Clrn,Q12,Qn12);D_FFEC32 q11(D,Clk,En[11],Clrn,Q11,Qn11);D_FFEC32 q10(D,Clk,En[10],Clrn,Q10,Qn10);D_FFEC32 q9(D,Clk,En[9],Clrn,Q9,Qn9);D_FFEC32 q8(D,Clk,En[8],Clrn,Q8,Qn8);D_FFEC32 q7(D,Clk,En[7],Clrn,Q7,Qn7);D_FFEC32 q6(D,Clk,En[6],Clrn,Q6,Qn6);D_FFEC32 q5(D,Clk,En[5],Clrn,Q5,Qn5);D_FFEC32 q4(D,Clk,En[4],Clrn,Q4,Qn4);D_FFEC32 q3(D,Clk,En[3],Clrn,Q3,Qn3);D_FFEC32 q2(D,Clk,En[2],Clrn,Q2,Qn2);D_FFEC32 q1(D,Clk,En[1],Clrn,Q1,Qn1);assign Q0=0;assign Qn0=0;endmodule32位32选1选择器moduleMUX32X32(Q31,Q30,Q29,Q28,Q27,Q26,Q25,Q24,Q23,Q22,Q21,Q20,Q19,Q18,Q17,Q16,Q15,Q14,Q13,Q12,Q1 1,Q10,Q9,Q8,Q7,Q6,Q5,Q4,Q3,Q2,Q1,Q0,S,Y);input[31:0]Q31,Q30,Q29,Q28,Q27,Q26,Q25,Q24,Q23,Q22,Q21,Q20,Q19,Q18,Q17,Q16,Q15,Q14,Q13,Q12,Q11,Q10, Q9,Q8,Q7,Q6,Q5,Q4,Q3,Q2,Q1,Q0;input [4:0]S;output [31:0]Y;function [31:0]select;input[31:0]Q31,Q30,Q29,Q28,Q27,Q26,Q25,Q24,Q23,Q22,Q21,Q20,Q19,Q18,Q17,Q16,Q15,Q14,Q13,Q12,Q11,Q10, Q9,Q8,Q7,Q6,Q5,Q4,Q3,Q2,Q1,Q0;input [4:0]S;case(S)5'b00000:select=Q0;5'b00001:select=Q1;5'b00010:select=Q2;5'b00011:select=Q3;5'b00100:select=Q4;5'b00101:select=Q5;5'b00110:select=Q6;5'b00111:select=Q7;5'b01000:select=Q8;5'b01001:select=Q9;5'b01010:select=Q10;5'b01011:select=Q11;5'b01100:select=Q12;5'b01101:select=Q13;5'b01110:select=Q14;5'b01111:select=Q15;5'b10000:select=Q16;5'b10001:select=Q17;5'b10010:select=Q18;5'b10011:select=Q19;5'b10100:select=Q20;5'b10101:select=Q21;5'b10110:select=Q22;5'b10111:select=Q23;5'b11000:select=Q24;5'b11001:select=Q25;5'b11010:select=Q26;5'b11011:select=Q27;5'b11100:select=Q28;5'b11101:select=Q29;5'b11110:select=Q30;5'b11111:select=Q31;endcaseendfunctionassign Y =select(Q31,Q30,Q29,Q28,Q27,Q26,Q25,Q24,Q23,Q22,Q21,Q20,Q19,Q18,Q17,Q16,Q15,Q14,Q13,Q12,Q11,Q10, Q9,Q8,Q7,Q6,Q5,Q4,Q3,Q2,Q1,Q0,S);endmoduleRTL视图如下:四、实验过程、数据记录与结果分析1.仿真测试文件:module REGFILE_Sim( );// REGFILE Inputsreg [4:0] Ra = 0 ;reg [4:0] Rb = 0 ;reg [4:0] Wr = 0 ;reg [31:0] D = 0 ;reg We = 0 ;reg Clk = 0 ;reg Clrn = 0 ;// REGFILE Outputswire [31:0] Qa ;wire [31:0] Qb ;REGFILE u_REGFILE (.Ra ( Ra [4:0] ),.Rb ( Rb [4:0] ),.Wr ( Wr [4:0] ),.D ( D [31:0] ),.We ( We ),.Clk ( Clk ),.Clrn ( Clrn ),.Qa ( Qa [31:0] ),.Qb ( Qb [31:0] ));initialbeginClk=0;We=0; D=0; Ra=0; Rb=0; Wr=1; Clrn=0;#10;endalways #10 Clk=~Clk;always #20 Ra=Ra+1;always #20 Rb=Rb+1;always #20 Wr=Wr+1;always #20 D=D+1;always #20 We=~We;always #100 Clrn=1;endmodule2.仿真测试结果:3.仿真测试结果分析开始时100ns内,Clrn=0,寄存器堆初始化清零,此期间内写入操作均无效,读出数据均为零。
杭电计组实验-寄存器堆设计实验
![杭电计组实验-寄存器堆设计实验](https://img.taocdn.com/s3/m/f5c2935bf705cc17552709b2.png)
杭电计组实验-寄存器堆设计实验————————————————————————————————作者:————————————————————————————————日期:实验报告2018 年 5 月12 日成绩:姓名阳光男学号班级专业计算机科学与技术课程名称《计算机组成原理与系统结构试验》任课老师张翔老师指导老师张翔老师机位号默认实验序号 4 实验名称《实验四寄存器堆设计》实验时间2018/5/12 实验地点1教211 实验设备号个人电脑、Nexys3开发板一、实验程序源代码1.寄存器堆模块代码:module Register_);input [4:0]R_Addr_A;input [4:0]R_Addr_B;input [4:0]W_Addr;input Write_Reg;input [31:0]W_Data;input Clk;input Reset;output [31:0]R_Data_A;output [31:0]R_Data_B;reg [31:0]REG_Files[0:31];reg [5:0]i;initial//仿真过程中的初始化beginfor(i=0;i<=31;i=i+1)REG_Files[i]=0;endassign R_Data_A=REG_Files[R_Addr_A]; assign R_Data_B=REG_Files[R_Addr_B]; always@(posedge Clk or posedge Reset)beginif(Reset)for(i=0;i<=31;i=i+1)REG_Files[i]=0;elseif(Write_Reg&&W_Addr!=0)REG_Files[W_Addr]=W_Data;endendmodule2.顶层电路模块代码:module Top_Register_);input [4:0]Addr;input [1:0]C1;//C1选择32位数据输出哪八位字节input Write_Reg,C2,Clk,Reset;//C2选择读A/B端口的数据output reg [7:0]LED;wire [31:0]R_Data_A,R_Data_B;reg [31:0]W_Data;reg[4:0] A,B;Register_(A,B,Addr,Write_Reg,W_Data,Clk,Reset,R_Data_A,R_Data_B); always@(Addr or Write_Reg or C1 or C2 or R_Data_A or R_Data_B) beginA=0;B=0;LED=0;W_Data=0;if(!Write_Reg)//读操作Write_Reg=0beginif(!C2)beginA=Addr;case(C1)2'b00:LED=R_Data_A[7:0];2'b01:LED=R_Data_A[15:8];2'b10:LED=R_Data_A[23:16];2'b11:LED=R_Data_A[31:24];endcaseendelsebeginB=Addr;case(C1)2'b00:LED=R_Data_B[7:0];2'b01:LED=R_Data_B[15:8];2'b10:LED=R_Data_B[23:16];2'b11:LED=R_Data_B[31:24];endcaseendendelse//写操作begincase(C1)2'b00:W_Data=32'h0000_0003;2'b01:W_Data=32'h0000_0607;2'b10:W_Data=32'hFFFF_FFFF;2'b11:W_Data=32'h1111_1234;endcaseendendendmodule3.测试代码module test;// Inputsreg [4:0] R_Addr_A;reg [4:0] R_Addr_B;reg [4:0] W_Addr;reg Write_Reg;reg [31:0] W_Data;reg Clk;reg Reset;// Outputswire [31:0] R_Data_A;wire [31:0] R_Data_B;// Instantiate the Unit Under Test (UUT) Register_ (.R_Addr_A(R_Addr_A),.R_Addr_B(R_Addr_B),.W_Addr(W_Addr),.Write_Reg(Write_Reg),.W_Data(W_Data),.Clk(Clk),.Reset(Reset),.R_Data_A(R_Data_A),.R_Data_B(R_Data_B));initial begin// Initialize InputsR_Addr_A = 0;R_Addr_B = 0;W_Addr = 0;Write_Reg = 0;W_Data = 0;Clk = 0;Reset = 0;// Wait 100 ns for global reset to finish #100;// Add stimulus here#100;R_Addr_A = 0;R_Addr_B = 0;W_Addr = 5'b00001; Write_Reg = 1;W_Data = 32'h1111_1111; Clk = 1;Reset = 0;#100;R_Addr_A = 0;R_Addr_B = 0;W_Addr = 5'b00001; Write_Reg = 1;W_Data = 32'h1111_1111; Clk = 0;Reset = 0;#100;R_Addr_A = 0;R_Addr_B = 0;W_Addr = 5'b00010; Write_Reg = 1;W_Data = 32'h2222_2222; Clk = 1;Reset = 0;#100;R_Addr_A = 5'b00001;R_Addr_B = 5'b00010;W_Addr = 0;Write_Reg = 0;W_Data = 0;Clk = 0;Reset = 0;#100;R_Addr_A = 5'b00001;R_Addr_B = 5'b00010;W_Addr = 0;Write_Reg = 0;W_Data = 0;Clk = 0;Reset = 1;endendmodule二、仿真波形三、电路图顶层电路模块顶层电路内部结构:四、引脚配置(约束文件)NET "Clk" LOC = C9;NET "Reset" LOC = D9;NET "Write_Reg" LOC = T5;NET "C2" LOC = C4;# PlanAhead Generated physical constraintsNET "LED[7]" LOC = T11;NET "LED[6]" LOC = R11;NET "LED[4]" LOC = M11;NET "LED[3]" LOC = V15;NET "LED[1]" LOC = V16;NET "LED[0]" LOC = U16;NET "LED[2]" LOC = U15;NET "LED[5]" LOC = N11;NET "Addr[0]" LOC = T10;NET "Addr[2]" LOC = V9;NET "Addr[3]" LOC = M8;NET "Addr[4]" LOC = N8;NET "C1[0]" LOC = U8;NET "C1[1]" LOC = V8;NET "Addr[1]" LOC = T9;五、思考与探索(1)实验四实验结果记录表寄存器地址写入数据读出数据$1 32'h0000_0003 32'h0000_0003$2 32'h0000_0607 32'h0000_0607$3 32'hFFFF_FFFF 32'hFFFF_FFFF $4 32'h1111_1234 32'h1111_1234$5 32'h0000_0003 32'h0000_0003$6 32'h0000_0607 32'h0000_0607$7 32'hFFFF_FFFF 32'hFFFF_FFFF $8 32'h1111_1234 32'h1111_1234。
一种基于活跃周期的低端口数低能耗寄存器堆设计
![一种基于活跃周期的低端口数低能耗寄存器堆设计](https://img.taocdn.com/s3/m/d2d3e3ce541810a6f524ccbff121dd36a22dc453.png)
一种基于活跃周期的低端口数低能耗寄存器堆设计
赵雨来;李险峰;佟冬;孙含欣;陈杰;程旭
【期刊名称】《计算机学报》
【年(卷),期】2008(31)2
【摘要】多端口寄存器堆有助于挖掘指令级和线程级并行性,但同时带来面积、能耗和访问时间的压力.文章面向超标量和SMT处理器,给出了一种方法,即通过增加一个小的活跃值堆(Active Value File,AVF)选择性地保存处于活跃周期(从产生到最后一次使用之间)的物理寄存器值.AVF结构可分担主寄存器堆的访问压力并降低端口数目,实现简单且具有写过滤的特点.在获得较大幅度能耗降低的同时不影响时钟频率且IPC损失较小.
【总页数】10页(P299-308)
【作者】赵雨来;李险峰;佟冬;孙含欣;陈杰;程旭
【作者单位】北京大学信息科学技术学院,北京,100871;北京大学信息科学技术学院,北京,100871;北京大学信息科学技术学院,北京,100871;北京大学信息科学技术学院,北京,100871;北京大学信息科学技术学院,北京,100871;北京大学信息科学技术学院,北京,100871
【正文语种】中文
【中图分类】TP303
【相关文献】
1.一种1 GHz多端口低功耗寄存器堆设计 [J], 李娇;王良华;毕卓;刘鹏
2.一种高速低功耗的三端口寄存器堆的设计 [J], 何玲莉;赵学梅;来逢昌;吕洞达
3.一种基于寄存器堆连接的可重组逻辑体系结构 [J], 杨光;张晓彤;王沁
4.一种高速低功耗多端口寄存器堆的设计 [J], 丛高建;齐家月
5.一种基于可配置共享寄存器堆的多核处理器核间数据交换结构设计 [J], 方颖;谢憬;王琴
因版权原因,仅展示原文概要,查看原文内容请购买。
寄存器队列装置及其设计方法
![寄存器队列装置及其设计方法](https://img.taocdn.com/s3/m/381dc5072e60ddccda38376baf1ffc4ffe47e220.png)
寄存器队列装置及其设计方法
王俊宇;夏宏;吴克河
【期刊名称】《计算机工程与应用》
【年(卷),期】2001(037)013
【摘要】介绍了寄存器堆队列装置(FIF0)的作用和设计原理.传统寄存器队列的设计多采用串行输入-串行输出,或者并行输入-并行输出的方式,该文介绍了两种并行输入-并行输出而且可以"边进边出”的寄存器队列装置,该装置可用于总线接口和先行控制处理机的设计中.
【总页数】3页(P7-9)
【作者】王俊宇;夏宏;吴克河
【作者单位】北京科技大学计算机系;北京科技大学计算机系;华北电力大学计算机系
【正文语种】中文
【中图分类】TP332.1+1
【相关文献】
1.寄存器堆设计方法研究 [J], 方卓红
2.基于可逆触发器的可逆移位寄存器设计方法 [J], 王友仁;沈先坤;周影辉
3.一种可用于嵌入式Java处理器的寄存器队列 [J], 王俊宇;忻凌;周维;周晓方;闵昊
4.通过寄存器队列模型实现寄存器分配和指令调度 [J], 沈立;肖晓强;戴葵;王志英
5.PLC梯形图程序的设计方法与技巧(八) 第八讲使用移位寄存器的顺序控制梯形图设计方法 [J], 廖常初
因版权原因,仅展示原文概要,查看原文内容请购买。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
寄存器堆设计1、功能概述:MIPS指令格式中的寄存器号是5bits,指令可以访问25=32个32位的寄存器。
这样的一堆寄存器“堆在一起”构成一个寄存器堆(Register File)。
2、接口说明:寄存器堆模块接口信号说明表脉冲reg,复位端reg,写使能端reg,写地址reg,写数据reg,读地址一reg,读地址二reg,读数据一reg,读数据二reg;设计思路:1、复位处理是利用标志位flag实现的,当复位时,flag=0;利用i来计数,当i<31时,flag都等于0;直到i=32,复位完成,flag=1,这时,才可以进行写操作。
2、当复位时,需要32个脉冲才能将寄存器全部复位。
复位未完成,flag一直等于0。
若复位未完成时,进行写操作,这时,并不能写进去,便出错了。
所以,进行32分频,当寄存器可以写入时,复位已完成。
3、设计电路源代码//----32个32位寄存器堆module regfile(input reg, //脉冲input reg, //复位端input reg, //写使能端input [4:0] reg读地址一input [4:0] reg读地址二input [4:0] reg, //写地址input [31:0] reg, //写数据output [31:0] reg读数据一output [31:0] reg读数据二);//----------------------------------reg [31:0]regfiles[0:31]; //实现寄存功能reg [4:0] i; //实现flag的变换reg flag; //实现复位的标志reg reg; //实现写数据的脉冲reg [4:0]count;//---32分频处理always@(posedge reg or posedge reg)beginif(reg)begincount<=5'd0;reg<=1'b0;endelse if(count<5'd16)begincount<=count+1'b1;endelsebegincount<=5'd0;reg<=~reg;endend//---复位处理always@(posedge reg or posedge reg)beginif(reg)begini<=5'd0;flag<=1'b0;endelse if(i<5'b11111)begini<=i+1'b1;flag<=1'b0;endelseflag<=1'b1;end//---写操作always@(posedge reg)beginif(~flag)regfiles[i]<=32'd0;elsebeginif(reg(reg'd0)) //写使能端为一,写地址不为零beginregfiles[reg]<=reg; //写入endendend//---读操作assign reg(reg'd0)?32'd0:regfiles[reg];assign reg(reg'd0)?32'd0:regfiles[reg];////----------------------------------------endmodule4、设计电路仿真所设计的指令存储器模块电路,采用ISE仿真器工具进行了设计仿真验证,验证结果表明存储器功能以及接口时序完全正确,如下是仿真验证的波形图。
附件1是仿真激励源代码。
图5 寄存器堆电路读写仿真波形图附件1:module reg;// Inputsreg clk;reg rst;reg Wen;reg [4:0] Raddr_1;reg [4:0] Raddr_2;reg [4:0] Waddr;reg [31:0]Wdata;// Outputswire [31:0] Rdata_1;wire [31:0] Rdata_2;// Instantiate the Unit Under Test (UUT)reg (.reg(clk),.reg(rst),.reg(Wen),.reg(Raddr_1),.reg(Raddr_2),.reg(Waddr),.reg(Wdata),.reg(Rdata_1),.reg(Rdata_2));always #0.25 clk<=~clk;reg [5:0]j,k;initial beginclk = 1'b0;rst = 1'b1;Wen = 1'b0;Raddr_1 = 5'd0;Raddr_2 = 5'd0;Waddr = 5'd0;Wdata = 32'd0;endinitial begin#16 rst = 1'b0; //复位#32 Wen = 1'b1; Waddr = 5'd5; Wdata = $random; //写操作#16 Waddr = 5'd30; Wdata = $random;#16 Waddr = 5'd0; Wdata = 32'hffff;#16 Wen= 1'b0; Raddr_1 = 5'd5; Raddr_2 = 5'd30; //无法写入无法写入#16 Raddr_1 = 5'd0;Raddr_2 = 5'd0;//----------------------------------------#16 Wen = 1'b1; //写操作for(j=0;j<6'd32;j=j+1)begin@(posedge clk) #16 Waddr = j;Wdata = 31-j;end//----------------------------------------#48 Wen = 1'b0; //读操作for(k=0;k<6'd32;k=k+1)begin@(posedge clk) #16 Raddr_1 = k;Raddr_2 = 31-k;endendendmodulemodule reg;// Inputsreg clk;reg rst;reg Wen;reg [4:0] Raddr_1;reg [4:0] Raddr_2;reg [4:0] Waddr;reg [31:0]Wdata;// Outputswire [31:0] Rdata_1;wire [31:0] Rdata_2;// Instantiate the Unit Under Test (UUT) reg (.reg(clk),.reg(rst),.reg(Wen),.reg(Raddr_1),.reg(Raddr_2),.reg(Waddr),.reg(Wdata),.reg(Rdata_1),.reg(Rdata_2));always #0.25 clk<=~clk;reg [5:0]j,k;initial beginclk = 1'b0;rst = 1'b1;Wen = 1'b0;Raddr_1 = 5'd0;Raddr_2 = 5'd0;Waddr = 5'd0;Wdata = 32'd0;endinitial begin#16 rst = 1'b0; //复位#32 Wen = 1'b1; Waddr = 5'd5; Wdata = $random; //写操作#16 Waddr = 5'd30; Wdata = $random;#16 Waddr = 5'd0; Wdata = 32'hffff;#16 Wen= 1'b0; Raddr_1 = 5'd5; Raddr_2 = 5'd30; //无法写入无法写入#16 Raddr_1 = 5'd0;Raddr_2 = 5'd0;//----------------------------------------#16 Wen = 1'b1; //写操作for(j=0;j<6'd32;j=j+1)begin@(posedge clk) #16 Waddr = j;Wdata = 31-j;end//----------------------------------------#48 Wen = 1'b0; //读操作for(k=0;k<6'd32;k=k+1)begin@(posedge clk) #16 Raddr_1 = k;Raddr_2 = 31-k;endendendmodule。