本文是为完全不了解CPU的朋友所写的入门级教程，对于较为精通的朋友，多数章节均为赘述，完整代码在下一篇博客中，请见谅哈

一、实现功能

实现了部分RV32I指令集中的部分指令类型，如下表

具体指令如下（不包括LB,LH,LBU,LHU,SB,SH指令）：

实现了单周期CPU和五级流水线。其中，五级流水线为顺序读取、顺序放回；跳转指令可以冲刷流水线；没有预测跳转功能；占用资源较多，微架构面积较大。

编程软件：Quartus Prime
编程语言：SystemVerilog
仿真软件：vivado 2018.3

二、认识CPU

1、什么是CPU？

CPU即中央处理器，是计算机系统的运算和控制中心，是信息处理、程序运行的最终执行单元。

常见的CPU有Intel公司的Core芯片，ARM公司的Cortex芯片，华为海思的麒麟芯片等等……

什么是芯片？通俗的来说，芯片就是封装起来的，可以实现一定功能的集成电路。例如，CPU能够实现运算与控制，GPU能够实现图像处理等。

如图，中央的封装即为一块芯片，这是用来将计算机的逻辑电平转换为硬件的逻辑电平，从而实现传递信息的一个芯片。由于这是十分常用的一个电路，于是将其封装为芯片。芯片右侧为一个下载电路，用来下载指令。若该功能也是一个常用功能，也可以将这些元件封装在芯片中。
CPU的数字电路结构实际十分简单，最主要的模块有PC（地址生成），ALU（运算），Register（寄存），Decode（译码），Control（控制信号生成）。CPU在工作时会与外部存储器Instr_mem（指令存储器）和Data_mem（数据存储器）交互，完成计算机生成的指令。下图为CPU的工作架构图。

2、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可能会执行更复杂的指令，上述分析仅是便于读者更好理解，具体工作原理博主也不能给出准确说明。

3、如何设计CPU？

CPU是基于指令集架构设计的，旨在执行指令。为助于理解，我讲述一个假想的关于CPU起源的故事（流水账）：

在很久很久以前，一个工程师想让计算机完成一个加法运算，于是，他设计了一个加法器，将存储器中的两个数据相加，写到了一个新的存储单元。这个想法很轻易得到了实现，他并不满足；接着，他希望计算机完成一系列运算，为了使计算有序的进行，他设计了一个地址自动迭代的数字电路，每执行完一条运算后，计算机会自动读取下一个地址的运算指令并进行运算，这就是PC模块。根据不同的计算指令，他设计了加法器，减法器，与运算器，或运算器，异或运算器，乘法器等等，由于这些都是用于计算的数字电路，于是将这些统称为ALU模块。在实际操作时，工程师发现，不断地读写存储器，对元件的损伤很大，并且执行速度慢¹，而在计算过程中，真正要存储的只有最终结果，计算过程中的数字刚存储完就要被擦除，十分浪费。所以，工程师设计了寄存器组Register²，将计算过程中的结果暂时输入，解决了问题。读存储器指令与写存储器指令也相继而生。后来，指令越来越多，很多都是重复的一套运算指令，在高级编程语言中可以用函数、类等模块化解决，于是设计师设计了跳转指令，如此，一套繁复的指令只用写一次，需要时通过一条跳转指令跳到该位置即可。这些繁多的指令在执行时，不一定需要所有的模块，比如跳转指令就不需要ALU模块，更无需向存储器存储数据，那么很多的模块都在做无用功甚至存入会不该存储的数据，那么就需要一个Control模块，根据不同的指令，生成不同的控制信号来控制各个模块的工作状态。随着指令不断地增多，指令的架构也愈发清晰起来，指令每一个数位都有了对应的意义（下文会讲到），为了更方便电路的设计，工程师加入了一个译码器，将指令拆分成多节，每一节传输到对应模块执行。工程师的故事还有很长，但本文要达到的技术到此就结束了。

(1)眼见为实

如图为常见的两种指令集：MIPS指令集与RISC-V指令集

可以看出，两种指令集的架构有异同之处，整体相似，细节有差。如MIPS的op码（指令类型）在31~26位，而RISC-V的op码在6~0位。对不同指令各数位的功能，会在后文解析。

(2)深入了解

指令集分为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)。

4、CPU的现状与前景

本节内容为博主了解到的片面之词，尽量做到所说的是经考证核实的，但肯定不能讲该领域的整个情况介绍完全(我还是个没见过世面的孩子，呜呜~)

(1)被垄断的产业链

Intel公司与AMD公司先发制人，在CPU诞生之初逐步排挤掉竞争对手，在计算机领域(PC)垄断了整个市场。现如今所有个人计算机的CPU都以x86为指令集架构，构建了城宽池阔的软件生态环境。对于如今已经成熟的计算机体系，想要插足简直是痴人说梦。首先，x86架构归Intel和AMD所有，若想设计相关CPU必须由Intel或AMD授权，交付费用，受制于人是在所难免的。如果威胁到其的产业链，想必一切努力都将付诸东流。其次，如果要用自己设计指令集设计CPU，那么一没技术，二没用户，现在的PC软件十分完善，娱乐、办公等软件深入到所有人的生活当中，除非再大费周折设计几千几万个对应的软件，否则用户是不可能倒戈的。
在手持设备(Mobile)领域，ARM公司的ARM指令集架构击败了MIPS这位昔日风流，成为了当今属实的霸主。不仅在Mobile领域，在生活中任何地方，小到手环、智能电器，延至工业、电子产业，均被ARM架构渗透。其成功的原因在于ARM公司的经营形式与卓越的眼光，将ARM架构作为知识产权授权给无数个合作伙伴，其中有芯片制造公司和买芯片的不同领域的生产商。华为海思的麒麟芯片便是基于ARM架构的。而近年美国对我国的打压，很可能使ISA(指令集架构)成为扼住国企脖颈的拴绳。

(2)打满补丁的袋子

Intel公司虽然称霸着PC领域，并在高性能服务器领域叱咤风云，但由于该公司的指令集架构是复杂指令集架构，就像装货前没有计算好货物大小的袋子，起初在试探性装载的时候，尚可轻松纳入，但随着装入的货物越来越多，袋子被撑破，Intel只好不断地打上补丁修补，但小袋子终究是小袋子，终有一天会达到极限。
为了优化硬件，减小空间开销并提升性能，指令集中的指令会被修改，那么可能会导致软件不兼容，运行出错。Intel可不能冒着失去用户的风险，那么就必须额外设计，兼容以往软件。Intel公司凭着尖端的技术优化了所有芯片的面积，并设计出极高性能的处理器，使得如今仍稳居产业链顶层，但终究有一天，CPU的面积要再度缩小，Intel只能放下手中这块肉，另辟蹊径了。

(3)翻身仗是一次长征——艰难但有希望

RISC-V的出现开辟了一条新的道路，给了我们不被别人牵着鼻子走的机会。这个完全开源，任何公司、个人都能免费使用的指令集架构可以作为打翻身仗的第一记炮响。

①眼光

主流的电子产品领域已经被瓜分完，各界大佬稳稳当当地享用着属于自己的战利品。于其虎口夺食，不如看看盘子里还剩下什么。5G正大张旗鼓地步入我们的生活，曾处于理念中的应用将随之而生。自动驾驶、虚拟现实、机器人等市场将逐渐扩大，成为新一代的主流产业。我们要高瞻远瞩，锁定目标，在起跑阶段就要取得领先。我国君正公司正是有卓越的眼光，看到了可穿戴设备以及物联网领域等市场，才有了鲸吞美国豪威的实力。

②创新

个人认为，PC会不久的将来永久失去市场，被新兴技术取而代之。小说《三体》危机纪元末期中，科技水平达到可以让一切事物智能化的程度。任何表面都是一个电子屏幕，人们可以随时随地使用身边的设施，计算机、笔记本已经绝迹了。亦或是科幻电影中的3D全息投影技术，不需要触摸键盘携带屏幕，所需信息以三维形式呈现在眼前，操作更直观化。还有电影《头号玩家》里那个可以取代现实世界的虚拟世界，是极有可能实现的。上述三种技术都可以取代PC、Mobile，开辟一个新的天地。我们需要积极创新，发展新兴技术，为取得未来市场做准备。

③决心

如此大型、尖端的科研技术想要获得一定的成果，离不开国家的投资与调控，时代很难再蕴育出像埃隆·马斯克这样的人才了。想要研究CPU，研究芯片，一定要投入大量资金，创造良好的科研环境，才能吸引人才进行基础研究。同时，国家也要宏观调控，带动产业链的发展，发展出一套完备的体系。路漫漫其修远兮，如此任重道远的使命，是每一位专业人士的责任与义务。只要国家下定决心，付诸行动，我辈当全力以赴，帮助国家弯道超车。

三、单周期CPU

上文说了那么多高大上的话，现在要接接地气了。我连设计一个芯片都设计不出来，哪敢有那样的雄心壮志，哈哈。

下文我将分享自己做CPU的思路。文字的表现能力有限，编写的思路可能不会十分清晰。我的b站视频展示了编写CPU的流程，但是没有提前做好功课，表达能力欠佳，建议博客与视频共同食用(把视频声音关上)。
基于RISC-V架构CPU的设计
github源码

1、运算指令

我们不妨跟随那位工程师的脚步，先从最基础的运算指令做起。

上述为一条整数变量加法指令，可通过如下代码理解：

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)begininstr[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;endcaseendcase
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

这就是完成一条指令的流程，下表为该类型指令的其他指令：

为完成这些指令，添加了如下代码：

ALU中增加了多种运算

module ALU();assign shamt = data_in2[4:0];always@(*)case(func3)3'b000: //ADD,SUB,ADDIcase(sub_en)1'b0: data_out <= data_in1 + data_in2;1'b1: data_out <= data_in1 - data_in2;endcase3'b001: data_out <= data_in1 << shamt; //SLL,SLLI3'b010: //SLT,SLTIif(data_in1[31] > data_in2[31]) data_out <= 32'd1;else if(data_in1[31] == data_in2[31])beginif(data_in1[31] < data_in2) data_out <= 32'd1;else data_out <= 32'd0;end else data_out <= 32'd0;3'b011: //SLTU,SLTIUif(data_in1 < data_in2) data_out <= 32'd1;else data_out <= 32'd0;3'b100: data_out <= data_in1 ^ data_in2; //XOR,XORI3'b101: //SRL,SRA,SRLI,SRAIcase(func)1'b0: data_out <= data_in1 >> shamt;1'b1: data_out <= {{31{data_in1[31]}},data_in1} >> shamt;endcase3'b110: data_out <= data_in1 | data_in2; //OR,ORI3'b111: data_out <= data_in1 & data_in2; //AND,ANDIdefault: 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

运算指令中还有另一个类型：操作数与立即数的运算

通过下述指令可用来理解指令的作用

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

下表为该指令类型的其他指令

为完成这些指令，增添了如下代码：

译码时分解出立即数

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

2、读、写存储器指令

在计算过程中，最开始的两个运算数是存储在Data_mem(数据存储器)当中的，需要用LW指令将其读取，写回到寄存器中；计算的最终结果需要SW指令从寄存器中读取，存放到存储器中。

下面是指令流程图。

与运算指令类型相比，访问存储器指令没有执行阶段，新增访问阶段。

数据存储器

module Data_mem();assign addr = ext_imm + data1;always@(lw_en)begindata_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];endalways@(sw_en)begindata[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

3、跳转指令

以下是无条件跳转指令。

以下是有条件指令。使用12位立即数(有符号数)作为偏移量，乘以2，然后与该指令的PC相加，生成得到最终的跳转目标地址。

下面是无条件跳转指令的流程图。

这两条指令通常搭配使用，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、五级流水线与单周期的差别

为方便起见，下文均以指令1，指令2，指令3，指令4来讲述四条顺序且连续执行的指令。
单周期CPU是在一个周期内执行一条完整的指令，在时钟上升沿时取指，高电平期间译码、执行、访问，时钟下降沿时写回；而五级流水线一个周期只用完成一个阶段。完成的任务少，所需的电路模块就会少，执行的时间短，处理器就可以有更高的频率。五级流水线，顾名思义，就是把一系列指令传入一条流水线中，高效、紧凑地完成每一条指令。当指令1在执行时，指令2已经在译码了。假设单周期的时钟周期为10s，五级流水线的时钟周期为2s，则单周期完成两条指令需要20s，而五级流水线只需12s，指令更多，节省的时间可想而知。
但是，每一级都是独立存在的，要确保一条指令正确地执行，就要做好级与级之间的交互(倘若能避免一些交互，自然是极好的)。比如指令1为ADD指令，当指令1进行到写回周期时，需要将数据写回到存储器rd中，而此时Decode输出的rd为指令4的rd，这就产生了错误。因此，在指令1的译码周期，就需要将指令1的rd放入寄存器中，等到写回周期时取出使用。本代码使用寄存器、移位寄存器完成这类操作，微架构(硬件)面积大，占用资源多，是比较笨拙的流水线。

2、举个栗子

思路：时钟上升沿输入数据，时钟下降沿输出数据。

使用名为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)begininstr[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; enddefault: begin sub_en <= 1'b0; wr_en <= 1'b0; endendcase
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;endcasedefault: 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寄存器都会产生逻辑冒险，发生问题。

3、稍作修改

(1)操作数与立即数运算指令

周期二完成关于输入到ALU中运算数的数据选择

module data_in2_sel();always@(negedge clk) data_in2 <= sel ? data2 : ext_imm;
endmodule

(2)跳转指令

周期二将跳转地址算出，而不是在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)beginjmp_en <= 1'b0; sub_en <= 1'b0; wr_en <= 1'b0;end else begincase(op)7'b0_110_011: begin jmp_en <= 1'b0; sub_en <= func ? 1'b1 : 1'b0; wr_en <= 1'b1; end7'b0_010_011: begin jmp_en <= 1'b0; sub_en <= 1'b0; wr_en <= 1'b1; end7'b1_101_111: begin jmp_en <= 1'b1; sub_en <= 1'b0; wr_en <= 1'b1; end7'b1_100_111: begin jmp_en <= 1'b1; sub_en <= 1'b0; wr_en <= 1'b1; end7'b1_100_011: begin jmp_en <= pass; sub_en <= 1'b0; wr_en <= 1'b0; enddefault: begin jmp_en <= 1'b0; sub_en <= 1'b0; wr_en <= 1'b0; endendcaseend
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

(3)读、写存储器指令

周期二将访问地址算出；

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。

4、存在问题

本文所述的五级流水线是顺序读取、顺序放回模式，这样的传输模式本身就存在一个漏洞，举一例：指令1的计算结果为指令2的加数。指令1需要在周期五将计算结果存入寄存器。指令2在周期三需要用到计算结果。但是指令2在周期三时，指令1仍在周期四，会造成使用数据的错误。不仅是寄存器的读写，存储器的读写也有这个问题。
解决方法：
①别写会造成冲突的指令
②加入fence指令，写入前不允许读取
③使用顺序读取乱序放回、乱序读取乱许放回模式。
感兴趣的朋友可以阅读《教你设计CPU——RISC-V处理器》深入了解

五、仿真

1、写一个指令文档

指令文档

@00000000000 0000000000000000 00000000@00400000001 0000000000000010 01101111@00800000000 0000000000000000 00000000@00c00000000 0000000000000000 00000000@01000000000 0000000000000000 00000000@01400000000 0000000000000000 00000000@01800000000 0000000000000000 00000000@01c00000000 0100001000000101 00110011@02000000000 0000000000000000 00000000@02400000000 0000000000000000 00000000@02800000000 0000000000000000 00000000@02c00000000 1010001000100000 10100011

2、写一个仿真文件

`timescale 1ns/1ns
`define clk_period 20module sim;reg clk;reg rst;cpu_1 cpu_1(.clk(clk),.rst(rst));initial clk = 1'b1;always#(`clk_period/2) clk = ~clk;initial beginrst = 1'b0;#100;rst = 1'b1;#100;rst = 1'b0;endendmodule

3、仿真

(1)单周期CPU

(2)五级流水线

4、大功告成！！！

由衷希望我的分享可以帮助到大家，感谢观看✧٩(ˊωˋ*)و✧

基于RISC-V指令集架构的单周期CPU与五级流水线的实现(一)——分析相关推荐

1. 基于 RICS-V 架构的单周期 38 条指令处理器设计（含源码及实验报告）

   一.概述   之前有专门的写过两篇博文来介绍基于 RICS-V 架构的单周期九条指令处理器设计,并提供了相关的代码结构介绍,之后我又对其进行了拓展,且修补了之前源码中存在的一些小问题,并将指令集从九条 ...

2. 基于 RICS-V 架构的单周期处理器设计（含所有格式指令）—— 逻辑部件概述

   文章目录 一.概述 二.原理图 2.1 ALU 2.1.1 ALU 操作控制信号生成部件 2.1.2 ALU 逻辑计算部件 2.1.3 ALU 整体逻辑 2.2 寄存器 2.2.1 Reg 整体逻辑 ...

3. 【Computer Organization笔记10】单周期CPU设计：基于7条MIPS指令的数据通路

   本次笔记内容: P19 计算机组成原理(19) P20 计算机组成原理(20) 本节课对应幻灯片: 组成原理24 singlecycle.pptx 基于上节课的7条MIPS指令的数据通路,分别针对7条 ...

4. verilog搭建单周期CPU与流水线CPU

   目录 实现功能与搭建环境介绍 单周期CPU 整体框图 具体代码 顶层模块 取值 译码 执行 访存 写回 流水线CPU 整体框图 前置知识及思路探讨 如何让流水线流起来~ Hazard_detect模块 ...

5. 2022 buaa CO P3（Logisim 实现单周期CPU）

   我的课上题目 T1:senodb rd,rs,rt 描述:统计rs和rt寄存器中不同位的个数,不同位个数为偶数rd置1,否则置0 32位指令格式:000000 rs rt rd 00000 10011 ...

6. 使用logisim搭建单周期CPU与添加指令

   使用logisim搭建单周期CPU与添加指令 搭建 总设计 借用高老板的图,我们只需要分别做出PC.NPC.IM.RF.EXT.ALU.DM.Controller模块即可,再按图连线,最后进行控制信号 ...

7. Risc-V单周期CPU设计思考

   Risc-V单周期CPU设计思考 今年学校课程改革,计算机组成课开始教学Risc-V,写单周期CPU的时候发现网上好像大多都是MIPS的CPU设计,所以就把自己关于设计Verilog的一些思路整理出来 ...

8. 【计算机组成原理】实验4:单周期CPU（Verilog）中海大

   [计算机组成原理]实验4 使用Verilog语言实现一个单周期CPU,测试平台:Vivado ①部分代码: single_cycle_cpu.v: `timescale 1ns / 1ps`defin ...

9. 31条指令单周期cpu设计(Verilog)-(二)总体设计

   目录 31条指令单周期cpu设计(Verilog)-(一)相关软件 31条指令单周期cpu设计(Verilog)-(二)总体设计 31条指令单周期cpu设计(Verilog)-(三)指令分析      ...

最新文章

1. SqlServer时间函数的使用例子整理
2. Redis 数据结构-字典源码分析
3. webstrom代码检查
4. WINCE下实现基于USB的camera
5. python 乱码转码_Python解决乱码问题
6. 放弃相爱，并不放弃彼此
7. c语言受到哪些编程的影响,C语言，一个影响了整个世界的编程语言！
8. AcWing 795. 前缀和
9. c++ primer 6.5.1节练习答案
10. 你足够了解Context吗？
11. SMARTS决策引擎技术白皮书
12. 双系统启动菜单删除无效Win启动菜单项
13. Elasticsearch Nested类型
14. 浅聊矢量场 —— 3. 什么是旋度(Rotational Vector)
15. 基于西门子S7-1200PLC的步进电机控制
16. 控制台输入类java.util.Scanner
17. ⑪(面试篇 2/3)、《史上最全iOS八股文面试题》2022年,金三银四我为你准备了,iOS《1000条》笔试题以及面试题(包含答案)。带面试你过关斩将,(赶紧过来背iOS八股文)
18. 女程序员开淘宝店兼职---详细注册成为淘宝商家步骤
19. 2021年亚马逊新手如何快速搭建店铺listing？五分钟让快速精通
20. JVM系列五JVM监测工具[整理中（转）

热门文章

1. TCP 和 HTTP
2. Linux开发环境配置--正点原子阿尔法开发板
3. 机器学习之KNN算法原理
4. 微服务架构-Day4
5. 从MTK的scat文件谈ROM和RAM的分配，管理和问题解决（拷贝）
6. 萌新爬坑系列-百度小程序自定义组件
7. 联想V系列存储升级微码详细教程
8. Sentinel不显示实时监控数据
9. 考研复试问答（十二）
10. 几种室内定位技术的简要介绍