本文是为完全不了解CPU的朋友所写的入门级教程,对于较为精通的朋友,多数章节均为赘述,完整代码在下一篇博客中,请见谅哈
实现了部分RV32I指令集中的部分指令类型,如下表
具体指令如下(不包括LB,LH,LBU,LHU,SB,SH指令):
实现了单周期CPU和五级流水线。其中,五级流水线为顺序读取、顺序放回;跳转指令可以冲刷流水线;没有预测跳转功能;占用资源较多,微架构面积较大。
编程软件:Quartus Prime
编程语言:SystemVerilog
仿真软件:vivado 2018.3
CPU即中央处理器,是计算机系统的运算和控制中心,是信息处理、程序运行的最终执行单元。
常见的CPU有Intel公司的Core芯片,ARM公司的Cortex芯片,华为海思的麒麟芯片等等……
什么是芯片?通俗的来说,芯片就是封装起来的,可以实现一定功能的集成电路。例如,CPU能够实现运算与控制,GPU能够实现图像处理等。
如图,中央的封装即为一块芯片,这是用来将计算机的逻辑电平转换为硬件的逻辑电平,从而实现传递信息的一个芯片。由于这是十分常用的一个电路,于是将其封装为芯片。芯片右侧为一个下载电路,用来下载指令。若该功能也是一个常用功能,也可以将这些元件封装在芯片中。
CPU的数字电路结构实际十分简单,最主要的模块有PC(地址生成),ALU(运算),Register(寄存),Decode(译码),Control(控制信号生成)。CPU在工作时会与外部存储器Instr_mem(指令存储器)和Data_mem(数据存储器)交互,完成计算机生成的指令。下图为CPU的工作架构图。
#include<iostream>
using namespace std;
int func(int x)
{
x = x + 1;
return x;
}
int main()
{
int a = 1;
int b = func(a);
}
引上述C++代码为例,当运行代码指令下发时,计算机会生成相应指令实现代码功能。如int b = func(a)
运行时,首先会执行跳转指令JAL,跳转到函数func
存储的地址;再执行立即数加法指令ADDI,得到所要的结果;最后执行跳转指令JALR,回到原先地址的下一个地址,对b
赋值。
实际的CPU可能会执行更复杂的指令,上述分析仅是便于读者更好理解,具体工作原理博主也不能给出准确说明。
CPU是基于指令集架构设计的,旨在执行指令。为助于理解,我讲述一个假想的关于CPU起源的故事(流水账):
在很久很久以前,一个工程师想让计算机完成一个加法运算,于是,他设计了一个加法器,将存储器中的两个数据相加,写到了一个新的存储单元。这个想法很轻易得到了实现,他并不满足;接着,他希望计算机完成一系列运算,为了使计算有序的进行,他设计了一个地址自动迭代的数字电路,每执行完一条运算后,计算机会自动读取下一个地址的运算指令并进行运算,这就是PC模块。根据不同的计算指令,他设计了加法器,减法器,与运算器,或运算器,异或运算器,乘法器等等,由于这些都是用于计算的数字电路,于是将这些统称为ALU模块。在实际操作时,工程师发现,不断地读写存储器,对元件的损伤很大,并且执行速度慢1,而在计算过程中,真正要存储的只有最终结果,计算过程中的数字刚存储完就要被擦除,十分浪费。所以,工程师设计了寄存器组Register2,将计算过程中的结果暂时输入,解决了问题。读存储器指令与写存储器指令也相继而生。后来,指令越来越多,很多都是重复的一套运算指令,在高级编程语言中可以用函数、类等模块化解决,于是设计师设计了跳转指令,如此,一套繁复的指令只用写一次,需要时通过一条跳转指令跳到该位置即可。这些繁多的指令在执行时,不一定需要所有的模块,比如跳转指令就不需要ALU模块,更无需向存储器存储数据,那么很多的模块都在做无用功甚至存入会不该存储的数据,那么就需要一个Control模块,根据不同的指令,生成不同的控制信号来控制各个模块的工作状态。随着指令不断地增多,指令的架构也愈发清晰起来,指令每一个数位都有了对应的意义(下文会讲到),为了更方便电路的设计,工程师加入了一个译码器,将指令拆分成多节,每一节传输到对应模块执行。工程师的故事还有很长,但本文要达到的技术到此就结束了。
如图为常见的两种指令集:MIPS指令集与RISC-V指令集
可以看出,两种指令集的架构有异同之处,整体相似,细节有差。如MIPS的op码(指令类型)在31~26位,而RISC-V的op码在6~0位。对不同指令各数位的功能,会在后文解析。
指令集分为CISC(复杂指令集)与RISC(精简指令集)。
CPU诞生早期,CISC因其可以用较少的指令完成更多的操作煊赫一时,但随着指令集发展,越来越多特殊指令加入到CISC指令集中。而运算中使用的80%指令,只占指令集中的20%,其余80%很少用到。但为了实现这些少用的特殊指令,又需要花费大量的研究时间、开销更大的硬件面积。而RISC只包含常用指令。对于特殊的操作,与CISC用一条特殊指令完成不同,RISC是通过多条常用指令配合完成的。
简单来讲,假如1
就是CISC中一条跳转+加法+存储指令,那的确十分方便,因为RISC需要3条32位的指令来执行。但CISC要根据跳转+减法+存储、跳转+乘法+读取……一系列不同组合设计不同的指令。指令数位不统一、数位模块不分明使得设计译码器十分艰难,CISC失宠了。而RISC的数位统一,均为16位,32位或64位(电脑是32位还是64位处理器的说法就是意思),而且每段数位有规定的功能,硬件设计就十分方便。但现在,我们用的电脑的CPU是基于x86指令集架构的,是一款CISC指令集。这是因为Intel公司在硬件中加入了硬件解码器,将指令微码化(CISC转RISC)。
本节内容为博主了解到的片面之词,尽量做到所说的是经考证核实的,但肯定不能讲该领域的整个情况介绍完全(我还是个没见过世面的孩子,呜呜~)
Intel公司与AMD公司先发制人,在CPU诞生之初逐步排挤掉竞争对手,在计算机领域(PC)垄断了整个市场。现如今所有个人计算机的CPU都以x86为指令集架构,构建了城宽池阔的软件生态环境。对于如今已经成熟的计算机体系,想要插足简直是痴人说梦。首先,x86架构归Intel和AMD所有,若想设计相关CPU必须由Intel或AMD授权,交付费用,受制于人是在所难免的。如果威胁到其的产业链,想必一切努力都将付诸东流。其次,如果要用自己设计指令集设计CPU,那么一没技术,二没用户,现在的PC软件十分完善,娱乐、办公等软件深入到所有人的生活当中,除非再大费周折设计几千几万个对应的软件,否则用户是不可能倒戈的。
在手持设备(Mobile)领域,ARM公司的ARM指令集架构击败了MIPS这位昔日风流,成为了当今属实的霸主。不仅在Mobile领域,在生活中任何地方,小到手环、智能电器,延至工业、电子产业,均被ARM架构渗透。其成功的原因在于ARM公司的经营形式与卓越的眼光,将ARM架构作为知识产权授权给无数个合作伙伴,其中有芯片制造公司和买芯片的不同领域的生产商。华为海思的麒麟芯片便是基于ARM架构的。而近年美国对我国的打压,很可能使ISA(指令集架构)成为扼住国企脖颈的拴绳。
Intel公司虽然称霸着PC领域,并在高性能服务器领域叱咤风云,但由于该公司的指令集架构是复杂指令集架构,就像装货前没有计算好货物大小的袋子,起初在试探性装载的时候,尚可轻松纳入,但随着装入的货物越来越多,袋子被撑破,Intel只好不断地打上补丁修补,但小袋子终究是小袋子,终有一天会达到极限。
为了优化硬件,减小空间开销并提升性能,指令集中的指令会被修改,那么可能会导致软件不兼容,运行出错。Intel可不能冒着失去用户的风险,那么就必须额外设计,兼容以往软件。Intel公司凭着尖端的技术优化了所有芯片的面积,并设计出极高性能的处理器,使得如今仍稳居产业链顶层,但终究有一天,CPU的面积要再度缩小,Intel只能放下手中这块肉,另辟蹊径了。
RISC-V的出现开辟了一条新的道路,给了我们不被别人牵着鼻子走的机会。这个完全开源,任何公司、个人都能免费使用的指令集架构可以作为打翻身仗的第一记炮响。
主流的电子产品领域已经被瓜分完,各界大佬稳稳当当地享用着属于自己的战利品。于其虎口夺食,不如看看盘子里还剩下什么。5G正大张旗鼓地步入我们的生活,曾处于理念中的应用将随之而生。自动驾驶、虚拟现实、机器人等市场将逐渐扩大,成为新一代的主流产业。我们要高瞻远瞩,锁定目标,在起跑阶段就要取得领先。我国君正公司正是有卓越的眼光,看到了可穿戴设备以及物联网领域等市场,才有了鲸吞美国豪威的实力。
个人认为,PC会不久的将来永久失去市场,被新兴技术取而代之。小说《三体》危机纪元末期中,科技水平达到可以让一切事物智能化的程度。任何表面都是一个电子屏幕,人们可以随时随地使用身边的设施,计算机、笔记本已经绝迹了。亦或是科幻电影中的3D全息投影技术,不需要触摸键盘携带屏幕,所需信息以三维形式呈现在眼前,操作更直观化。还有电影《头号玩家》里那个可以取代现实世界的虚拟世界,是极有可能实现的。上述三种技术都可以取代PC、Mobile,开辟一个新的天地。我们需要积极创新,发展新兴技术,为取得未来市场做准备。
如此大型、尖端的科研技术想要获得一定的成果,离不开国家的投资与调控,时代很难再蕴育出像埃隆·马斯克这样的人才了。想要研究CPU,研究芯片,一定要投入大量资金,创造良好的科研环境,才能吸引人才进行基础研究。同时,国家也要宏观调控,带动产业链的发展,发展出一套完备的体系。路漫漫其修远兮,如此任重道远的使命,是每一位专业人士的责任与义务。只要国家下定决心,付诸行动,我辈当全力以赴,帮助国家弯道超车。
上文说了那么多高大上的话,现在要接接地气了。我连设计一个芯片都设计不出来,哪敢有那样的雄心壮志,哈哈。
下文我将分享自己做CPU的思路。文字的表现能力有限,编写的思路可能不会十分清晰。我的b站视频展示了编写CPU的流程,但是没有提前做好功课,表达能力欠佳,建议博客与视频共同食用(把视频声音关上)。
基于RISC-V架构CPU的设计
github源码
我们不妨跟随那位工程师的脚步,先从最基础的运算指令做起。
rs2 | rs1 | func3 | rd | op | 指令名称 | |
---|---|---|---|---|---|---|
0000000 | rs2 | rs1 | 000 | rd | 0110011 | ADD |
31~25 | 24~20 | 19~15 | 14~12 | 11~7 | 6~0 | instruction |
上述为一条整数变量加法指令,可通过如下代码理解:
int c = a + b;
rs1
与rs2
为int a
和int b
在寄存器数组中的索引,即a = register[rs1]
,b = register[rs2]
。
op
为0110011,代表这是整数变量运算类型指令,func3
为000,代表这是加减法运算,31~25位的0000000为待扩展的功能码,本文所使用的指令中只会用到30位。
rd
为int c
在寄存器数组中的索引,当完成加法运算后,要将数值存入该地址当中。
执行此指令需要经过如下步骤:
PC生成地址,Instr_mem输出对应的指令,Decode翻译分解指令,从Register读取两个运算数a和b,送入ALU进行运算,经Control判断,允许将结果c写回到Register
我在录制视频时使用过这张图片,不方便修改,请见谅
在PC端生成地址
module PC();
always@(negedge clk or posedge rst) //时钟下降沿时生成新的地址(便于下文跳转指令执行)
if(rst) next_addr <= 32'd0;
else next_addr <= addr + 4;
always@(posedge clk or posedge rst) //时钟上升沿指向新的地址
if(rst) addr <= 32'd0;
else addr <= next_addr;
endmodule
取指
module Instr_mem();
initial $readmemb("C:/Users/86136/Desktop/vivado/Quartus/cpu/cpu.txt",instr_mem); //初始化时将我们编写的指令写入存储器
always@(addr)begin
instr[7:0] <= instr_mem[addr+3];
instr[15:8] <= instr_mem[addr+2];
instr[23:16] <= instr_mem[addr+1];
instr[31:24] <= instr_mem[addr];
end
endmodule
译码
module Decode();
assign op = instr[6:0];
assign rd = instr[11:7];
assign func3 = instr[14:12];
assign rs1 = instr[19:15];
assign rs2 = instr[24:20];
assign func = instr[30];
endmodule
在存储器中读取数据
module Register();
assign data1 = (rs1 != 0) ? register[rs1] : 0;
assign data2 = (rs2 != 0) ? register[rs2] : 0;
endmodule
执行
module ALU();
always@(*)
case(func3)
3'b000:
case(sub_en)
1'b0: data_out <= data_in1 + data_in2;
endcase
endcase
endmodule
产生控制信号,此代码需要wr_en(寄存器写使能)信号
module Control();
assign wr_en = (op == 7'b0_110_011) ? 1'b1 : 1'b0;
endmodule
写回
module Register();
always@(negedge clk)
if(wr_en) register[rd] <= wr_data;
endmodule
这就是完成一条指令的流程,下表为该类型指令的其他指令:
rs2 | rs1 | func3 | rd | op | 指令名称 | 功能 | |
---|---|---|---|---|---|---|---|
0100000 | rs2 | rs1 | 000 | rd | 0110011 | SUB | c = a - b |
0000000 | rs2 | rs1 | 001 | rd | 0110011 | SLL | 对操作数寄存器rs1中的整数值进行逻辑左移运算(低位补入0),移位量为寄存器rs2中整数值的低5位,结果写回寄存器rd中 |
0000000 | rs2 | rs1 | 010 | rd | 0110011 | SLT | 将操作数寄存器rs1中的整数值与寄存器rs2中的整数值当作有符号数进行比较。如果rs1中的值小于rs2中的值,则结果为1,否则为0,结果写回寄存器rd中 |
0000000 | rs2 | rs1 | 011 | rd | 0110011 | SLTU | 将操作数寄存器rs1中的整数值与寄存器rs2中的整数值当作无符号数进行比较。如果rs1中的值小于rs2中的值,则结果为1,否则为0,结果写回寄存器rd中 |
0000000 | rs2 | rs1 | 100 | rd | 0110011 | XOR | c = a ^ b |
0000000 | rs2 | rs1 | 101 | rd | 0110011 | SRL | 对操作数寄存器rs1中的整数值进行逻辑右移运算(高位补入0),移位量为寄存器rs2中整数值的低5位,结果写回寄存器rd中 |
0100000 | rs2 | rs1 | 101 | rd | 0110011 | SRA | 对操作数寄存器rs1中的整数值进行逻辑右移运算(高位补入符号位),移位量为寄存器rs2中整数值的低5位,结果写回寄存器rd中 |
0000000 | rs2 | rs1 | 110 | rd | 0110011 | OR | c = a |
0000000 | rs2 | rs1 | 111 | rd | 0110011 | AND | c = a & b |
为完成这些指令,添加了如下代码:
ALU中增加了多种运算
module ALU();
assign shamt = data_in2[4:0];
always@(*)
case(func3)
3'b000: //ADD,SUB,ADDI
case(sub_en)
1'b0: data_out <= data_in1 + data_in2;
1'b1: data_out <= data_in1 - data_in2;
endcase
3'b001: data_out <= data_in1 << shamt; //SLL,SLLI
3'b010: //SLT,SLTI
if(data_in1[31] > data_in2[31]) data_out <= 32'd1;
else if(data_in1[31] == data_in2[31])begin
if(data_in1[31] < data_in2) data_out <= 32'd1;
else data_out <= 32'd0;
end else data_out <= 32'd0;
3'b011: //SLTU,SLTIU
if(data_in1 < data_in2) data_out <= 32'd1;
else data_out <= 32'd0;
3'b100: data_out <= data_in1 ^ data_in2; //XOR,XORI
3'b101: //SRL,SRA,SRLI,SRAI
case(func)
1'b0: data_out <= data_in1 >> shamt;
1'b1: data_out <= {
{
31{
data_in1[31]}},data_in1} >> shamt;
endcase
3'b110: data_out <= data_in1 | data_in2; //OR,ORI
3'b111: data_out <= data_in1 & data_in2; //AND,ANDI
default: data_out <= 32'd0;
endcase
endmodule
Control中增加了sub_en(减法使能)信号
module Control();
assign wr_en = (op == 7'b0_110_011) ? 1'b1 : 1'b0;
assign sub_en = ((op == 7'b0_110_011)&func) ? 1'b1 : 1'b0;
endmodule
运算指令中还有另一个类型:操作数与立即数的运算
imm[11:0] | rs1 | func3 | rd | op | 指令名称 |
---|---|---|---|---|---|
imm[11:0] | rs1 | 000 | rd | 0010011 | ADDI |
31~20 | 19~15 | 14~12 | 11~7 | 6~0 | instruction |
通过下述指令可用来理解指令的作用
int c = a + 1;
立即数即直接可以用的数,不需要从寄存器读取。下图是指令流程图。
经分析,会发现一个矛盾。ALU中data_in2
的来源有两处,一处为符号位扩展器Ext32输出的ext_imm
,另一处为寄存器Register输出的data2
。这里就需要加入一个数据选择器解决此矛盾。在操作数运算指令执行时,需要输入data2
;在操作数与立即数运算指令执行时,需要输入ext_imm
。因此,可以使用op作为判断的依据。op分别为0110011、0010011,只需取op[5]即可。
module data_in2_sel();
assign data_in2 = sel ? data2 : ext_imm; //sel = op[5]
endmodule
下表为该指令类型的其他指令
imm[11:0] | rs1 | func3 | rd | op | 指令名称 | 功能 |
---|---|---|---|---|---|---|
0000000|shamt | rs1 | 001 | rd | 0010011 | SLLI | 对操作数寄存器rs1中的整数值进行逻辑左移运算(低位补入0),移位量为5位立即数shamt,结果写回寄存器rd中 |
imm[11:0] | rs1 | 010 | rd | 0010011 | SLTI | 将操作数寄存器rs1中的整数值与12位立即数(进行符号位扩展)当作有符号数进行比较。如果rs1中的值小于立即数的值,结果为1,否则为0,结果写回寄存器中 |
imm[11:0] | rs1 | 011 | rd | 0010011 | SLTIU | 将操作数寄存器rs1中的整数值与12位立即数(仍进行符号位扩展)当作无符号数进行比较。如果rs1中的值小于立即数的值,结果为1,否则为0,结果写回寄存器中 |
imm[11:0] | rs1 | 100 | rd | 0010011 | XORI | c = a ^ imm |
0000000|shamt | rs1 | 101 | rd | 0010011 | SRLI | 对操作数寄存器rs1中的整数值进行逻辑右移运算(高位补入0),移位量为5位立即数shamt,结果写回寄存器rd中 |
0100000|shamt | rs1 | 101 | rd | 0010011 | SRAI | 对操作数寄存器rs1中的整数值进行逻辑右移运算(高位补入符号位),移位量为5位立即数shamt,结果写回寄存器rd中 |
imm[11:0] | rs1 | 110 | rd | 0010011 | ORI | c = a |
imm[11:0] | rs1 | 111 | rd | 0010011 | ANDI | c = a & imm |
为完成这些指令,增添了如下代码:
译码时分解出立即数
module Decode();
assign op = instr[6:0];
assign rd = instr[11:7];
assign func3 = instr[14:12];
assign rs1 = instr[19:15];
assign rs2 = instr[24:20];
assign func = instr[30];
assign imm = (~op[6]&~op[5]&op[4]&~op[3]&~op[2]&op[1]&op[0])*instr[31:20];
endmodule
立即数符号位扩展
module Ext32();
assign ext_imm = {
{
20{
imm[11]}},imm};
endmodule
控制端产生wr_en信号
module Control();
assign wr_en = ((op == 7'b0_110_011)||(op == 7'b0_010_011)) ? 1'b1 : 1'b0;
endmodule
imm[11:0] | rs1 | func3 | rd | op | 指令名称 | 指令功能 |
---|---|---|---|---|---|---|
imm[11:0] | rs1 | 010 | rd | 0000011 | LW | 从存储器中读回一个32位数据,写回寄存器rd中,访问存储器的地址由操作数寄存器rs1中的值与12位的立即数(进行符号位扩展)相加所得 |
31~20 | 19~15 | 14~12 | 11~7 | 6~0 | instruction |
imm[11:5] | rs2 | rs1 | func3 | imm[4:0] | op | 指令名称 | 指令功能 |
---|---|---|---|---|---|---|---|
imm[11:5] | rs2 | rs1 | 010 | imm[4:0] | 0100011 | SW | 将操作数寄存器rs2中的32位数据,写回存储器中,访问存储器的地址由操作数寄存器rs1中的值与12位的立即数(进行符号位扩展)相加所得 |
31~25 | 24~20 | 19~15 | 14~12 | 11~7 | 6~0 | instruction |
在计算过程中,最开始的两个运算数是存储在Data_mem(数据存储器)当中的,需要用LW指令将其读取,写回到寄存器中;计算的最终结果需要SW指令从寄存器中读取,存放到存储器中。
下面是指令流程图。
与运算指令类型相比,访问存储器指令没有执行阶段,新增访问阶段。
数据存储器
module Data_mem();
assign addr = ext_imm + data1;
always@(lw_en)begin
data_mem[7:0] <= data[addr];
data_mem[15:8] <= data[addr+1];
data_mem[23:16] <= data[addr+2];
data_mem[31:24] <= data[addr+3];
end
always@(sw_en)begin
data[addr+3] <= data2[7:0];
data[addr+2] <= data2[15:8];
data[addr+1] <= data2[23:16];
data[addr] <= data2[31:24];
end
endmodule
经分析,发现一个矛盾。写回寄存器的数据来源有两处。一处为ALU运算后输出的data_out
,另一处为存储器读取的data_mem
。此处需要添加一个数据选择器。
module wr_data_sel();
assign wr_data = sel1 ? data_out : data_mem; //sel1 = op[4]
endmodule
为完成指令,对代码做了如下改动:
module Decode();
assign op = instr[6:0];
assign rd = instr[11:7];
assign func3 = instr[14:12];
assign rs1 = instr[19:15];
assign rs2 = instr[24:20];
assign func = instr[30];
assign imm = (~op[6]&~op[5]&op[4]&~op[3]&~op[2]&op[1]&op[0])*instr[31:20]+
(~op[6]&~op[5]&~op[4]&~op[3]&~op[2]&op[1]&op[0])*instr[31:20]+
(~op[6]&op[5]&~op[4]&~op[3]&~op[2]&op[1]&op[0])*{
instr[31:25],instr[11:7]};
endmodule
module Control();
assign wr_en = ((op == 7'b0_110_011)||(op == 7'b0_010_011)||(op == 7'b0_000_011)) ? 1'b1 : 1'b0;
assign sub_en = ((op == 7'b0_110_011)&func) ? 1'b1 : 1'b0;
assign lw_en = (op == 7'b0_000_011) ? 1'b1 : 1'b0;
assign sw_en = (op == 7'b0_100_011) ? 1'b1 : 1'b0;
endmodule
以下是无条件跳转指令。
imm[20|10:1|11|19:12] | rd | op | 指令名称 | 指令功能 |
---|---|---|---|---|
imm[20|10:1|11|19:12] | rd | 1101111 | JAL | 使用20位立即数(有符号数)作为偏移量,乘以2,然后与该指令的PC相加,生成得到最终的跳转目标地址。同时,将其下一条指令的PC(即当前指令PC+4)的值写入寄存器rd中 |
31~12 | 11~7 | 6~0 | instruction |
imm[11:0] | rs1 | func3 | rd | op | 指令名称 | 指令功能 |
---|---|---|---|---|---|---|
imm[11:0] | rs1 | 000 | rd | 1100111 | JALR | 使用12位立即数(有符号数)作为偏移量,与操作数寄存器rs1中的值相加,得到最终的跳转目标地址。同时,将其下一条指令的PC(即当前指令PC+4)的值写入寄存器rd中 |
31~20 | 19~15 | 14~12 | 11~7 | 6~0 | instruction |
以下是有条件指令。使用12位立即数(有符号数)作为偏移量,乘以2,然后与该指令的PC相加,生成得到最终的跳转目标地址。
imm[12|10:5] | rs2 | rs1 | func3 | imm[4:1|11] | op | 指令名称 | 指令功能 |
---|---|---|---|---|---|---|---|
imm[12|10:5] | rs2 | rs1 | 000 | imm[4:1|11] | 1100011 | BEQ | 只有操作数寄存器rs1中的数值与操作数寄存器rs2中的数值相等时,才会跳转 |
imm[12|10:5] | rs2 | rs1 | 001 | imm[4:1|11] | 1100011 | BNE | 只有操作数寄存器rs1中的数值与操作数寄存器rs2中的数值不相等时,才会跳转 |
imm[12|10:5] | rs2 | rs1 | 100 | imm[4:1|11] | 1100011 | BLT | 只有操作数寄存器rs1中的有符号数小于操作数寄存器rs2中的有符号数时,才会跳转 |
imm[12|10:5] | rs2 | rs1 | 101 | imm[4:1|11] | 1100011 | BGE | 只有操作数寄存器rs1中的有符号数大于或等于操作数寄存器rs2中的有符号数时,才会跳转 |
imm[12|10:5] | rs2 | rs1 | 110 | imm[4:1|11] | 1100011 | BLTU | 只有操作数寄存器rs1中的无符号数小于操作数寄存器rs2中的无符号数时,才会跳转 |
imm[12|10:5] | rs2 | rs1 | 111 | imm[4:1|11] | 1100011 | BGEU | 只有操作数寄存器rs1中的无符号数大于或等于操作数寄存器rs2中的无符号数时,才会跳转 |
31~25 | 24~20 | 19~15 | 14~12 | 11~7 | 6~0 | instruction |
下面是无条件跳转指令的流程图。
这两条指令通常搭配使用,JAL指令从主函数跳至子函数,JALR指令从子函数跳回主函数。对CPU最大的改动就是PC模块,让下一条地址指向跳转地址。代码如下。
module PC();
always@(negedge clk or posedge rst)
if(rst) next_addr <= 32'd0;
else if(jmp_en) next_addr <= addr + (offset << 1);
else if(jmpr_en) next_addr <= offset;
else next_addr <= addr + 4;
always@(posedge clk or posedge rst)
if(rst) addr <= 32'd0;
else addr <= next_addr;
endmodule
offset
是数据选择器输出的偏移量,该数据选择器代码如下:
module offset_sel();
always@(*)
case(sel) //sel = op[3:2]
2'b11: offset <= jmp;
2'b01: offset <= ext_imm + data1;
default: offset <= 31'd0;
endcase
endmodule
实现有条件跳转指令只需额外加一个判断模块,决定是否跳转,这里只列出一个判断,全部代码详见下一篇博客(放一个网页里面是不是不太方便看呀)。
module pass_jud();
always@(*)
case(func3)
3'b000:
if(data1 == data2) pass <= 1'b1;
else pass <= 1'b0;
default: pass <= 1'b0;
endcase
endmodule
将判断信号pass
传输都Control决定是否跳转
module Control();
assign jmpb_en = ((op == 7'b1_100_011)&pass) ? 1'b1 : 1'b0;
endmodule
为完成以上指令,又需要在Decode中分解出对应的立即数,在Control中产生相应的控制信号。并且,一些端口的数据来源又扩大了。比如wr_data_sel(写回寄存器选择器)增加了跳转指令要存储的下一条地址,offset_sel(偏移量选择器)增加了有条件跳转指令的偏移量。这些都需要对代码块进行微调。在混乱不知所措的时候,从头到尾将指令的执行过程大声读出来检查就好了。
我做的b站视频在该部分的编写过程个人认为可以看一下,展现方式会比文字清晰,关上声音,下面的文字更善于与您沟通
为方便起见,下文均以指令1,指令2,指令3,指令4来讲述四条顺序且连续执行的指令。
单周期CPU是在一个周期内执行一条完整的指令,在时钟上升沿时取指,高电平期间译码、执行、访问,时钟下降沿时写回;而五级流水线一个周期只用完成一个阶段。完成的任务少,所需的电路模块就会少,执行的时间短,处理器就可以有更高的频率。五级流水线,顾名思义,就是把一系列指令传入一条流水线中,高效、紧凑地完成每一条指令。当指令1在执行时,指令2已经在译码了。假设单周期的时钟周期为10s,五级流水线的时钟周期为2s,则单周期完成两条指令需要20s,而五级流水线只需12s,指令更多,节省的时间可想而知。
但是,每一级都是独立存在的,要确保一条指令正确地执行,就要做好级与级之间的交互(倘若能避免一些交互,自然是极好的)。比如指令1为ADD指令,当指令1进行到写回周期时,需要将数据写回到存储器rd中,而此时Decode输出的rd为指令4的rd,这就产生了错误。因此,在指令1的译码周期,就需要将指令1的rd放入寄存器中,等到写回周期时取出使用。本代码使用寄存器、移位寄存器完成这类操作,微架构(硬件)面积大,占用资源多,是比较笨拙的流水线。
思路:时钟上升沿输入数据,时钟下降沿输出数据。
使用名为receive的寄存器取出输入数据
module receive #(parameter N = 32)(
input clk,
input [N-1:0]data,
output reg [N-1:0]data_r
);
always@(posedge clk) data_r <= data;
endmodule
使用名为delay的寄存器存入输出数据
module delay #(parameter N = 32)(
input clk,
input [N-1:0]data,
output reg [N-1:0]data_d
);
always@(negedge clk) data_d <= data;
endmodule
使用名为shift的移位寄存器取出搁置多个周期的输入数据
module shift #(parameter M = 3, N = 32)(
input clk,
input [N-1:0]data,
output [N-1:0]data_s
);
reg [M*N-1:0]shift;
always@(posedge clk) shift <= {
shift[(M-1)*N-1:0],data};
assign data_s = shift[M*N-1:(M-1)*N];
endmodule
以ADD指令为例
周期一:取指,下降沿将指令instr
放入delay寄存器中
module PC();
always@(negedge clk or posedge rst)
if(rst) addr <= 32'd0;
else addr <= addr + 4;
endmodule
module Instr_mem();
always@(addr)begin
instr[7:0] <= instr_mem[addr+3];
instr[15:8] <= instr_mem[addr+2];
instr[23:16] <= instr_mem[addr+1];
instr[31:24] <= instr_mem[addr];
end
endmodule
周期二:译码,上升沿用receive寄存器取出指令,下降沿将data1
,data2
,rd
等后续周期需要使用的数据放入delay寄存器,由于Control模块本身就是下降沿执行,因此不需要将控制使能存入delay寄存器
module Decode();
assign op = instr[6:0];
assign rd = instr[11:7];
assign func3 = instr[14:12];
assign rs1 = instr[19:15];
assign rs2 = instr[24:20];
assign func = instr[30];
endmodule
module Control();
always@(negedge clk)
case(op)
7'b0_110_011: begin sub_en <= func ? 1'b1 : 1'b0; wr_en <= 1'b1; end
default: begin sub_en <= 1'b0; wr_en <= 1'b0; end
endcase
endmodule
module Register();
assign data1 = (rs1 != 0) ? register[rs1] : 0;
assign data2 = (rs2 != 0) ? register[rs2] : 0;
endmodule
周期三:执行,上升沿用receive寄存器取出data1
,data2
等数据,将rd
,wr_en
等数据放入shift寄存器,在周期五使用。下降沿将计算结果data_out
放入delay寄存器
module ALU();
always@(*)
case(func3)
3'b000:
case(sub_en)
1'b0: data_out <= data_in1 + data_in2;
1'b1: data_out <= data_in1 - data_in2;
endcase
default: data_out <= 32'd0;
endcase
endmodule
周期四:访问,ADD指令无需访问存储器,该周期组件做无用功
周期五:写回,上升沿shift寄存器输出的数据为该指令的rd
与wr_en
,下降沿写回数据
module Register();
always@(negedge clk)
if(wr_en) register[rd] <= wr_data;
endmodule
大体框架编写完成,次级顶层文件如下(写回到寄存器的数据来源没有写出,因为这个数据要经过两级的筛选):
module cpu();
//第一级
pc pc_cpu(clk,rst,cancel,offset_r,addr);
//第二级
receive #32 r_instr(clk,instr,instr_r);
decode decode_cpu(instr_r,op,rd,func3,rs1,rs2,func);
control control_cpu(clk,op,func,sub_en,wr_en);
delay #32 d_data1(clk,data1,data1_d);
delay #32 d_data2(clk,data2,data2_d);
delay #5 d_rd(clk,rd,rd_d);
delay #3 d_func3(clk,func3,func3_d);
delay #1 d_func(clk,func,func_d);
//第三级
shift #(3,5) s_rd(clk,rd_d,rd_s);
shift #(3,1) s_wr_en(clk,wr_en,wr_en_s);
receive #32 r_data1(clk,data1_d,data1_r);
receive #32 r_data_in2(clk,data_in2,data_in2_r);
receive #3 r_func3(clk,func3_d,func3_r);
receive #1 r_func(clk,func_d,func_r);
receive #1 r_sub_en(clk,sub_en,sub_en_r);
alu alu(data1_r,data_in2_r,func3_r,func_r,sub_en_r,data_out);
//第四级
//第五级
register register_cpu(clk,rs1,rs2,rd_s,data_r,wr_en_s,data1,data2);
endmodule
写完上述代码,读者对五级流水线的架构有了初步的理解,就可以思考本代码中delay寄存器与receive寄存器的用途了。
如上图,指令1在周期一产生数据a1
,数据a1
是周期二需要用到的,于是,在时钟下降沿时,让a_d = a1
,在周期二时钟上升沿时,让a_r = a_d = a1
。此时,第二条指令产生数据a2
,在周期二时钟下降沿时,a_d = a2
,但这不会影响到指令1对a_r = a1
的使用,因为a_r
在周期三的时钟上升沿时,才会更新数据,让a_r = a_d = a2
。可见,数据a1
可以作用于一整个周期。失去delay或receive寄存器都会产生逻辑冒险,发生问题。
周期二完成关于输入到ALU中运算数的数据选择
module data_in2_sel();
always@(negedge clk) data_in2 <= sel ? data2 : ext_imm;
endmodule
周期二将跳转地址算出,而不是在PC中计算;
module offset_sel();
always@(negedge clk)
case(sel)
2'b11: offset <= addr + (jmp << 1);
2'b01: offset <= ext_imm + data1;
2'b00: offset <= addr + (ext_imm << 1);
default: offset <= 32'd0;
endcase
endmodule
周期二完成有条件跳转指令的判断;
module pass_jud();
always@(*)
case(func3)
3'b000:
if(data1 == data2) pass <= 1'b1;
else pass <= 1'b0;
default: pass <= 1'b0;
endcase
endmodule
周期三上升沿读取跳转使能,实现以下控制:指令2在周期二产生的控制信号全部清零,达到冲刷流水线的目的。改变PC读取的地址,达到跳转的目的;(即指令2会进行,但做的是无用功。指令3不会执行,而是执行跳转地址存储的指令)
module Control();
always@(negedge clk)
if(cancel)begin
jmp_en <= 1'b0; sub_en <= 1'b0; wr_en <= 1'b0;
end else begin
case(op)
7'b0_110_011: begin jmp_en <= 1'b0; sub_en <= func ? 1'b1 : 1'b0; wr_en <= 1'b1; end
7'b0_010_011: begin jmp_en <= 1'b0; sub_en <= 1'b0; wr_en <= 1'b1; end
7'b1_101_111: begin jmp_en <= 1'b1; sub_en <= 1'b0; wr_en <= 1'b1; end
7'b1_100_111: begin jmp_en <= 1'b1; sub_en <= 1'b0; wr_en <= 1'b1; end
7'b1_100_011: begin jmp_en <= pass; sub_en <= 1'b0; wr_en <= 1'b0; end
default: begin jmp_en <= 1'b0; sub_en <= 1'b0; wr_en <= 1'b0; end
endcase
end
endmodule
module PC();
always@(negedge clk or posedge rst)
if(rst) addr <= 32'd0;
else if(cancel) addr <= offset;
else addr <= addr + 4;
endmodule
周期三完成第一次写回存储器的数据选择;
module wr_data_sel();
always@(negedge clk) wr_data <= sel ? addr : data_out;
endmodule
周期二将访问地址算出;
module wr_addr();
always@(negedge clk) wr_addr <= ext_imm + data1;
endmodule
周期四完成第二次写回存储器的数据选择;
module wr_data_sel();
always@(negedge clk) wr_data <= sel ? addr : data_out;
endmodule
上述是我的五级流水线设计思路,完整代码详见下一篇文章或我的github。
本文所述的五级流水线是顺序读取、顺序放回模式,这样的传输模式本身就存在一个漏洞,举一例:指令1的计算结果为指令2的加数。指令1需要在周期五将计算结果存入寄存器。指令2在周期三需要用到计算结果。但是指令2在周期三时,指令1仍在周期四,会造成使用数据的错误。不仅是寄存器的读写,存储器的读写也有这个问题。
解决方法:
①别写会造成冲突的指令
②加入fence指令,写入前不允许读取
③使用顺序读取乱序放回、乱序读取乱许放回模式。
感兴趣的朋友可以阅读《教你设计CPU——RISC-V处理器》深入了解
指令文档
@000
00000000 00000000
00000000 00000000
@004
00000001 00000000
00000010 01101111
@008
00000000 00000000
00000000 00000000
@00c
00000000 00000000
00000000 00000000
@010
00000000 00000000
00000000 00000000
@014
00000000 00000000
00000000 00000000
@018
00000000 00000000
00000000 00000000
@01c
00000000 01000010
00000101 00110011
@020
00000000 00000000
00000000 00000000
@024
00000000 00000000
00000000 00000000
@028
00000000 00000000
00000000 00000000
@02c
00000000 10100010
00100000 10100011
`timescale 1ns/1ns
`define clk_period 20
module sim;
reg clk;
reg rst;
cpu_1 cpu_1(.clk(clk),.rst(rst));
initial clk = 1'b1;
always#(`clk_period/2) clk = ~clk;
initial begin
rst = 1'b0;
#100;
rst = 1'b1;
#100;
rst = 1'b0;
end
endmodule
由衷希望我的分享可以帮助到大家,感谢观看✧٩(ˊωˋ*)و✧
文章浏览阅读1.6k次。安装配置gi、安装数据库软件、dbca建库见下:http://blog.csdn.net/kadwf123/article/details/784299611、检查集群节点及状态:[root@rac2 ~]# olsnodes -srac1 Activerac2 Activerac3 Activerac4 Active[root@rac2 ~]_12c查看crs状态
文章浏览阅读1.3w次,点赞45次,收藏99次。我个人用的是anaconda3的一个python集成环境,自带jupyter notebook,但在我打开jupyter notebook界面后,却找不到对应的虚拟环境,原来是jupyter notebook只是通用于下载anaconda时自带的环境,其他环境要想使用必须手动下载一些库:1.首先进入到自己创建的虚拟环境(pytorch是虚拟环境的名字)activate pytorch2.在该环境下下载这个库conda install ipykernelconda install nb__jupyter没有pytorch环境
文章浏览阅读5.2k次,点赞19次,收藏28次。选择scoop纯属意外,也是无奈,因为电脑用户被锁了管理员权限,所有exe安装程序都无法安装,只可以用绿色软件,最后被我发现scoop,省去了到处下载XXX绿色版的烦恼,当然scoop里需要管理员权限的软件也跟我无缘了(譬如everything)。推荐添加dorado这个bucket镜像,里面很多中文软件,但是部分国外的软件下载地址在github,可能无法下载。以上两个是官方bucket的国内镜像,所有软件建议优先从这里下载。上面可以看到很多bucket以及软件数。如果官网登陆不了可以试一下以下方式。_scoop-cn
文章浏览阅读4.5k次,点赞2次,收藏3次。首先要有一个color-picker组件 <el-color-picker v-model="headcolor"></el-color-picker>在data里面data() { return {headcolor: ’ #278add ’ //这里可以选择一个默认的颜色} }然后在你想要改变颜色的地方用v-bind绑定就好了,例如:这里的:sty..._vue el-color-picker
文章浏览阅读640次。基于芯片日益增长的问题,所以内核开发者们引入了新的方法,就是在内核中只保留函数,而数据则不包含,由用户(应用程序员)自己把数据按照规定的格式编写,并放在约定的地方,为了不占用过多的内存,还要求数据以根精简的方式编写。boot启动时,传参给内核,告诉内核设备树文件和kernel的位置,内核启动时根据地址去找到设备树文件,再利用专用的编译器去反编译dtb文件,将dtb还原成数据结构,以供驱动的函数去调用。firmware是三星的一个固件的设备信息,因为找不到固件,所以内核启动不成功。_exynos 4412 刷机
文章浏览阅读2w次,点赞24次,收藏42次。Linux系统配置jdkLinux学习教程,Linux入门教程(超详细)_linux配置jdk
文章浏览阅读3.3k次,点赞5次,收藏19次。xlabel('\delta');ylabel('AUC');具体符号的对照表参照下图:_matlab微米怎么输入
文章浏览阅读119次。顺序读写指的是按照文件中数据的顺序进行读取或写入。对于文本文件,可以使用fgets、fputs、fscanf、fprintf等函数进行顺序读写。在C语言中,对文件的操作通常涉及文件的打开、读写以及关闭。文件的打开使用fopen函数,而关闭则使用fclose函数。在C语言中,可以使用fread和fwrite函数进行二进制读写。 Biaoge 于2024-03-09 23:51发布 阅读量:7 ️文章类型:【 C语言程序设计 】在C语言中,用于打开文件的函数是____,用于关闭文件的函数是____。
文章浏览阅读3.4k次,点赞2次,收藏13次。跟随鼠标移动的粒子以grid(SOP)为partical(SOP)的资源模板,调整后连接【Geo组合+point spirit(MAT)】,在连接【feedback组合】适当调整。影响粒子动态的节点【metaball(SOP)+force(SOP)】添加mouse in(CHOP)鼠标位置到metaball的坐标,实现鼠标影响。..._touchdesigner怎么让一个模型跟着鼠标移动
文章浏览阅读178次。项目运行环境配置:Jdk1.8 + Tomcat7.0 + Mysql + HBuilderX(Webstorm也行)+ Eclispe(IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持)。项目技术:Springboot + mybatis + Maven +mysql5.7或8.0+html+css+js等等组成,B/S模式 + Maven管理等等。环境需要1.运行环境:最好是java jdk 1.8,我们在这个平台上运行的。其他版本理论上也可以。_基于java技术的停车场管理系统实现与设计
文章浏览阅读3.5k次。前言对于MediaPlayer播放器的源码分析内容相对来说比较多,会从Java-&amp;gt;Jni-&amp;gt;C/C++慢慢分析,后面会慢慢更新。另外,博客只作为自己学习记录的一种方式,对于其他的不过多的评论。MediaPlayerDemopublic class MainActivity extends AppCompatActivity implements SurfaceHolder.Cal..._android多媒体播放源码分析 时序图
文章浏览阅读2.4k次,点赞41次,收藏13次。java 数据结构与算法 ——快速排序法_快速排序法