基于RISC-V指令集架构的单周期CPU与五级流水线的实现(二)——源码

最新推荐文章于 2024-07-09 21:28:50 发布
最新推荐文章于 2024-07-09 21:28:50 发布
阅读量6.1k 收藏 165
点赞数 28
文章标签： verilog cpu risc-v 经验分享
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kubidaolun/article/details/113360009
版权

一、单周期CPU

顶层文件cpu_1

module cpu_1(
	input clk,
	input rst
);

	wire [31:0]addr;
	wire [31:0]instr;
	wire [31:0]ext_imm;
	wire [31:0]data1;
	wire [31:0]data2;
	wire lw_en;
	wire sw_en;
	wire [31:0]data_mem;

	instr_mem instr_mem_cpu(addr,instr);
	cpu cpu_cpu(clk,rst,data_mem,instr,addr,data1,data2,ext_imm,lw_en,sw_en);
	data_mem data_mem_cpu(ext_imm,data1,data2,lw_en,sw_en,data_mem);

endmodule

次级顶层文件cpu

module cpu(
	input clk,
	input rst,
	input [31:0]data_mem,
	input [31:0]instr,
	output [31:0]addr,
	output [31:0]data1,
	output [31:0]data2,
	output [31:0]ext_imm,
	output lw_en,
	output sw_en
);

	wire jmp_en;
	wire jmpr_en;
	wire jmpb_en;
	wire [31:0]offset;
	wire [6:0]op;
	wire [4:0]rd;
	wire [2:0]func3;
	wire [4:0]rs1;
	wire [4:0]rs2;
	wire func;
	wire [11:0]imm;
	wire [31:0]jmp;
	wire wr_en;
	wire [31:0]wr_data;
	wire [31:0]data_in2;
	wire sub_en;
	wire [31:0]data_out;
	wire pass;
	
	pc pc_cpu(clk,rst,jmp_en,jmpr_en,jmpb_en,offset,addr);
	decode decode_cpu(instr,op,rd,func3,rs1,rs2,func,imm,jmp);
	register register_cpu(clk,wr_en,rs1,rs2,rd,wr_data,data1,data2);
	alu alu_cpu(data1,data_in2,func3,func,sub_en,data_out);
	control control_cpu(op,func,pass,wr_en,sub_en,jmp_en,jmpr_en,jmpb_en,lw_en,sw_en);
	ext32 ext32_cpu(imm,ext_imm);
	data_in2_sel data_in2_sel_cpu(data2,ext_imm,op[5],data_in2);
	wr_data_sel wr_data_sel_cpu(data_out,addr,data_mem,op[4],op[6],wr_data);
	offset_sel offset_sel_cpu(jmp,ext_imm,data1,op[3:2],offset);
	pass_jud pass_jud_cpu(data1,data2,func3,pass);

endmodule

PC

module pc(
	input clk,
	input rst,
	input jmp_en,
	input jmpr_en,
	input jmpb_en,
	input [31:0]offset,
	output reg [31:0]addr
);

	reg [31:0]next_addr;

	initial begin addr = 32'd0; next_addr = 32'd0; end
	
	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 if(jmpb_en) next_addr <= addr + (offset << 1);
		else next_addr <= addr + 4;
	
	always@(posedge clk or posedge rst)
		if(rst) addr <= 32'd0;
		else addr <= next_addr;

endmodule

ALU

module alu(
	input [31:0]data_in1,
	input [31:0]data_in2,
	input [2:0]func3,
	input func,
	input sub_en,
	output reg [31:0]data_out
);

	wire [4:0]shamt;
	
	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

module control(
	input [6:0]op,
	input func,
	input pass,
	output wr_en,
	output sub_en,
	output jmp_en,
	output jmpr_en,
	output jmpb_en,
	output lw_en,
	output sw_en
);

	assign wr_en = ((op == 7'b0_110_011)||(op == 7'b0_010_011)||(op == 7'b1_101_111)||(op == 7'b1_100_111)||(op == 7'b0_000_011)) ? 1'b1 : 1'b0;
	assign sub_en = ((op == 7'b0_110_011)&func) ? 1'b1 : 1'b0;
	assign jmp_en = (op == 7'b1_101_111) ? 1'b1 : 1'b0;
	assign jmpr_en = (op == 7'b1_100_111) ? 1'b1 : 1'b0;
	assign jmpb_en = ((op == 7'b1_100_011)&pass) ? 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

data_in2_sel

module data_in2_sel(
	input [31:0]data2,
	input [31:0]ext_imm,
	input sel, //op[5]
	output [31:0]data_in2
);

	assign data_in2 = sel ? data2 : ext_imm;

endmodule

次级顶层文件Data_mem

module data_mem(
	input [31:0]ext_imm,
	input [31:0]data1,
	input [31:0]data2,
	input lw_en,
	input sw_en,
	output reg [31:0]data_mem
);

	wire [31:0]addr;

	reg [7:0]data[0:31];
	
	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

Decode

module decode(
	input [31:0]instr,
	output [6:0]op,
	output [4:0]rd,
	output [2:0]func3,
	output [4:0]rs1,
	output [4:0]rs2,
	output func,
	output [11:0]imm,
	output [31:0]jmp
);

	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 jmp = {{12{instr[31]}},instr[31],instr[19:12],instr[20],instr[30:21]};
	assign imm = (op[6]&op[5]&~op[4]&~op[3]&op[2]&op[1]&op[0])*instr[31:20]+                                   //无条件跳转jalr指令
					 (op[6]&op[5]&~op[4]&~op[3]&~op[2]&op[1]&op[0])*{instr[31],instr[7],instr[30:25],instr[11:8]}+ //有条件跳转指��?
					 (~op[6]&~op[5]&~op[4]&~op[3]&~op[2]&op[1]&op[0])*instr[31:20]+                                //读存储器lw指令
					 (~op[6]&op[5]&~op[4]&~op[3]&~op[2]&op[1]&op[0])*{instr[31:25],instr[11:7]}+                   //写存储器sw指令
					 (~op[6]&~op[5]&op[4]&~op[3]&~op[2]&op[1]&op[0])*instr[31:20];                                 //立即数运算指��?


endmodule

ext32

module ext32(
	input [11:0]imm,
	output [31:0]ext_imm
);

	assign ext_imm = {{20{imm[11]}},imm};

endmodule

次级顶层文件Instr_mem

module instr_mem(
	input [31:0]addr,
	output reg [31:0]instr
);

	reg [7:0]instr_mem[0:31];
	
	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

offset_sel

module offset_sel(
	input [31:0]jmp,
	input [31:0]ext_imm,
	input [31:0]data1,
	input [1:0]sel, //op[3:2]
	output reg [31:0]offset
);

	always@(*)
		case(sel)
			2'b11: offset <= jmp;
			2'b01: offset <= ext_imm + data1;
			2'b00: offset <= ext_imm;
			default: offset <= 31'd0;
		endcase

endmodule

pass_jud

module pass_jud(
	input [31:0]data1,
	input [31:0]data2,
	input [2:0]func3,
	output reg pass
);

	always@(*)
		case(func3)
			3'b000: 
				if(data1 == data2) pass <= 1'b1;
				else pass <= 1'b0;
			3'b001:
				if(data1 != data2) pass <= 1'b1;
				else pass <= 1'b0;
			3'b100:
				if(data1[31] > data2[31]) pass <= 32'd1;
				else if(data1[31] == data2[31])begin
					if(data1[31] < data2) pass <= 32'd1;
					else pass <= 32'd0;
				end else pass <= 32'd0;
			3'b101:
				if(data1[31] > data2[31]) pass <= 32'd0;
				else if(data1[31] == data2[31])begin
					if(data1[31] < data2) pass <= 32'd0;
					else pass <= 32'd1;
				end else pass <= 32'd1;
			3'b110:
				if(data1 < data2) pass <= 1'b1;
				else pass <= 1'b0;
			3'b111:
				if(data1 < data2) pass <= 1'b0;
				else pass <= 1'b1;
			default: pass <= 1'b0;
		endcase

endmodule

Register

module register(
	input clk,
	input wr_en,
	input [4:0]rs1,
	input [4:0]rs2,
	input [4:0]rd,
	input [31:0]wr_data,
	output [31:0]data1,
	output [31:0]data2
);

	reg [31:0]register[1:31];

	assign data1 = (rs1 != 0) ? register[rs1] : 0;
	assign data2 = (rs2 != 0) ? register[rs2] : 0;
	
	always@(negedge clk)
		if(wr_en) register[rd] <= wr_data;

endmodule

wr_data_sel

module wr_data_sel(
	input [31:0]data_out,
	input [31:0]addr,
	input [31:0]data_mem,
	input sel1, //op[4]
	input sel2, //op[6]
	output [31:0]wr_data
);

	assign wr_data = sel1 ? data_out : (sel2 ? (addr + 4) : data_mem);

endmodule

仿真文件sim

`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

二、五级流水线

顶层文件cpu_2

module cpu_2(
	input clk,
	input rst
);
	
	wire [31:0]addr;
	wire [31:0]instr;
	wire [31:0]wr_addr_s;
	wire [31:0]data2_s;
	wire lw_en_s;
	wire sw_en_s;
	wire [31:0]data_mem;

	instr_mem instr_mem_cpu(addr,instr);
	cpu cpu_cpu(clk,rst,instr,data_mem,addr,wr_addr_s,data2_s,lw_en_s,sw_en_s);
	data_mem data_mem_cpu(clk,wr_addr_s,data2_s,lw_en_s,sw_en_s,data_mem);

endmodule

cpu

module cpu(
	input clk,
	input rst,
	input [31:0]instr,
	input [31:0]data_mem,
	output [31:0]addr,
	output [31:0]wr_addr_s,
	output [31:0]data2_s,
	output [31:0]lw_en_s,
	output [31:0]sw_en_s
);

	wire [31:0]addr_r;
	wire [31:0]instr_r;
	wire [6:0]op;
	wire [4:0]rd;
	wire [4:0]rd_d;
	wire [4:0]rd_s;
	wire [2:0]func3;
	wire [2:0]func3_d;
	wire [2:0]func3_r;
	wire [4:0]rs1;
	wire [4:0]rs2;
	wire func;
	wire func_d;
	wire func_r;
	wire [11:0]imm;
	wire [31:0]jmp;
	wire sub_en;
	wire sub_en_r;
	wire [31:0]data1;
	wire [31:0]data1_d;
	wire [31:0]data1_r;
	wire [31:0]data2;
	wire [31:0]data2_d;
	wire [31:0]data_out;
	wire wr_en;
	wire wr_en_s;
	wire [31:0]wr_data;
	wire [31:0]wr_data_r;
	wire [31:0]ext_imm;
	wire [31:0]data_in2;
	wire [31:0]data_in2_r;
	wire pass;
	wire jmp_en;
	wire cancel;
	wire [31:0]offset;
	wire [31:0]offset_r;
	wire [31:0]wr_addr;
	wire [31:0]data;
	wire [31:0]data_r;
	wire [31:0]lw_en;
	wire [31:0]sw_en;

	//第一级
	pc pc_cpu(clk,rst,cancel,offset_r,addr);
	//第二级
	receive #32 r_instr(clk,instr,instr_r);
	receive #32 r_addr(clk,addr,addr_r);
	decode decode_cpu(instr_r,op,rd,func3,rs1,rs2,func,imm,jmp);
	ext32 ext32_cpu(imm,ext_imm);
	pass_jud pass_jud_cpu(data1,data2,func3,pass);
	control control_cpu(clk,op,func,pass,cancel,sub_en,wr_en,jmp_en,lw_en,sw_en);
	data_in2_sel data_in2_sel_cpu(clk,data2,ext_imm,op[5],data_in2);
	offset_sel offset_sel_cpu(clk,jmp,addr_r,ext_imm,data1,op[3:2],offset);
	wr_addr wr_addr_cpu(clk,ext_imm,data1,wr_addr);
	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 #(2,32) s_wr_addr(clk,wr_addr,wr_addr_s);
	shift #(2,32) s_data2(clk,data2_d,data2_s);
	shift #(2,1) s_lw_en(clk,lw_en,lw_en_s);
	shift #(2,1) s_sw_en(clk,sw_en,sw_en_s);
	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_offset(clk,offset,offset_r);
	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);
	receive #1 r_jmp_en(clk,jmp_en,cancel);
	alu alu(data1_r,data_in2_r,func3_r,func_r,sub_en_r,data_out);
	wr_data_sel wr_data_sel1(clk,data_out,addr_r,cancel,wr_data);
	//第四级
	receive #32 r_wr_data(clk,wr_data,wr_data_r);
	wr_data_sel wr_data_sel2(clk,wr_data_r,data_mem,lw_en_s,data);
	//第五级
	receive #32 r_data(clk,data,data_r);
	register register_cpu(clk,rs1,rs2,rd_s,data_r,wr_en_s,data1,data2);

endmodule

ALU

module alu(
	input [31:0]data_in1,
	input [31:0]data_in2,
	input [2:0]func3,
	input func,
	input sub_en,
	output reg [31:0]data_out
);

	wire [4:0]shamt;
	
	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

module control(
	input clk,
	input [6:0]op,
	input func,
	input pass,
	input cancel,
	output reg sub_en,
	output reg wr_en,
	output reg jmp_en,
	output reg lw_en,
	output reg sw_en
);

	always@(negedge clk)begin
		if(cancel)begin
			sw_en <= 1'b0; lw_en <= 1'b0; jmp_en <= 1'b0; sub_en <= 1'b0; wr_en <= 1'b0;
		end else begin
			case(op)
				7'b0_110_011: begin sw_en <= 1'b0; lw_en <= 1'b0; jmp_en <= 1'b0; sub_en <= func ? 1'b1 : 1'b0; wr_en <= 1'b1; end
				7'b0_010_011: begin sw_en <= 1'b0; lw_en <= 1'b0; jmp_en <= 1'b0; sub_en <= 1'b0; wr_en <= 1'b1; end
				7'b1_101_111: begin sw_en <= 1'b0; lw_en <= 1'b0; jmp_en <= 1'b1; sub_en <= 1'b0; wr_en <= 1'b1; end
				7'b1_100_111: begin sw_en <= 1'b0; lw_en <= 1'b0; jmp_en <= 1'b1; sub_en <= 1'b0; wr_en <= 1'b1; end
				7'b1_100_011: begin sw_en <= 1'b0; lw_en <= 1'b0; jmp_en <= pass; sub_en <= 1'b0; wr_en <= 1'b0; end
				7'b0_000_011: begin sw_en <= 1'b0; lw_en <= 1'b1; jmp_en <= 1'b0; sub_en <= 1'b0; wr_en <= 1'b1; end
				7'b0_100_011: begin sw_en <= 1'b1; lw_en <= 1'b0; jmp_en <= 1'b0; sub_en <= 1'b0; wr_en <= 1'b0; end
				default: begin sw_en <= 1'b0; lw_en <= 1'b0; jmp_en <= 1'b0; sub_en <= 1'b0; wr_en <= 1'b0; end
			endcase
		end
	end

endmodule

data_in2_sel

module data_in2_sel(
	input clk,
	input [31:0]data2,
	input [31:0]ext_imm,
	input sel, //op[5]
	output reg [31:0]data_in2
);

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

endmodule

Data_mem

module data_mem(
	input clk,
	input [31:0]addr,
	input [31:0]data2,
	input lw_en,
	input sw_en,
	output reg [31:0]data_mem
);

	reg [7:0]data[0:255];
	
	always@(lw_en)
		if(lw_en)begin
			data_mem[7:0] <= data[addr+3];
			data_mem[15:8] <= data[addr+2];
			data_mem[23:16] <= data[addr+1];
			data_mem[31:24] <= data[addr];
		end
	
	always@(negedge clk)
		if(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

Decode

module decode(
	input [31:0]instr,
	output [6:0]op,
	output [4:0]rd,
	output [2:0]func3,
	output [4:0]rs1,
	output [4:0]rs2,
	output func,
	output [11:0]imm,
	output [31:0]jmp
);

	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  jmp = {{12{instr[31]}},instr[31],instr[19:12],instr[20],instr[30:21]};
	assign imm = (op[6]&op[5]&~op[4]&~op[3]&op[2]&op[1]&op[0])*instr[31:20]+                                   //无条件跳转jalr指令
					 (op[6]&op[5]&~op[4]&~op[3]&~op[2]&op[1]&op[0])*{instr[31],instr[7],instr[30:25],instr[11:8]}+ //有条件跳转指��?
					 (~op[6]&~op[5]&~op[4]&~op[3]&~op[2]&op[1]&op[0])*instr[31:20]+                                //读存储器lw指令
					 (~op[6]&op[5]&~op[4]&~op[3]&~op[2]&op[1]&op[0])*{instr[31:25],instr[11:7]}+                   //写存储器sw指令
					 (~op[6]&~op[5]&op[4]&~op[3]&~op[2]&op[1]&op[0])*instr[31:20];                                 //立即数运算指��?


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

ext32

module ext32 #(parameter N = 12)(
	input [N-1:0]imm,    //待扩展的立即数
	output [31:0]ext_imm //已扩展的立即数
);

	assign ext_imm = {{(32-N){imm[N-1]}},imm};

endmodule

Instr_mem

module instr_mem(
	input [31:0]addr,
	output reg [31:0]instr
);

	reg [7:0]instr_mem[0:255];
	
	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

offset_sel

module offset_sel(
	input clk,
	input [31:0]jmp,
	input [31:0]addr,
	input [31:0]ext_imm,
	input [31:0]data1,
	input [1:0]sel, //op[3:2]
	output reg [31:0]offset
);

	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

pass_jud

module pass_jud(
	input [31:0]data1,
	input [31:0]data2,
	input [2:0]func3,
	output reg pass
);

	always@(*)
		case(func3)
			3'b000: 
				if(data1 == data2) pass <= 1'b1;
				else pass <= 1'b0;
			3'b001:
				if(data1 != data2) pass <= 1'b1;
				else pass <= 1'b0;
			3'b100:
				if(data1[31] > data2[31]) pass <= 32'd1;
				else if(data1[31] == data2[31])begin
					if(data1[31] < data2) pass <= 32'd1;
					else pass <= 32'd0;
				end else pass <= 32'd0;
			3'b101:
				if(data1[31] > data2[31]) pass <= 32'd0;
				else if(data1[31] == data2[31])begin
					if(data1[31] < data2) pass <= 32'd0;
					else pass <= 32'd1;
				end else pass <= 32'd1;
			3'b110:
				if(data1 < data2) pass <= 1'b1;
				else pass <= 1'b0;
			3'b111:
				if(data1 < data2) pass <= 1'b0;
				else pass <= 1'b1;
			default: pass <= 1'b0;
		endcase

endmodule

PC

module pc(
	input clk,
	input rst,
	input cancel,
	input [31:0]offset,
	output reg [31:0]addr
);

	initial addr = 32'd0;
	
	always@(negedge clk or posedge rst)
		if(rst) addr <= 32'd0;
		else if(cancel) addr <= offset;
		else addr <= addr + 4;

endmodule

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

Register

module register(
	input clk,
	input [4:0]rs1,
	input [4:0]rs2,
	input [4:0]rd,
	input [31:0]wr_data,
	input wr_en,
	output [31:0]data1,
	output [31:0]data2
);

	reg [31:0]register[1:31];

	assign data1 = (rs1 != 0) ? register[rs1] : 0;
	assign data2 = (rs2 != 0) ? register[rs2] : 0;
	
	always@(negedge clk)
		if(wr_en) register[rd] <= wr_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

wr_addr

module wr_addr(
	input clk,
	input [31:0]ext_imm,
	input [31:0]data1,
	output reg [31:0]wr_addr
);

	always@(negedge clk) wr_addr <= ext_imm + data1;

endmodule

wr_data_sel

module wr_data_sel(
	input clk,
	input [31:0]data_out,
	input [31:0]addr,
	input sel, //op[6]
	output reg [31:0]wr_data
);

	always@(negedge clk) wr_data <= sel ? addr : data_out;

endmodule

仿真文件sim

`timescale 1ns/1ns
`define clk_period 20

module sim;

	reg clk;
	reg rst;
	
	initial clk = 1'b1;
	
	always#(`clk_period/2) clk = ~clk;
	
	initial begin
		rst = 0;
		#100;
		rst = 1;
		#100;
		rst =0;
	end
	
	cpu_2 cpux(.clk(clk),.rst(rst));
	
endmodule
TheRoguePlanet
关注
从零开始的RISCV架构CPU设计（1）-CPU开源资料说明
PPRAM的博客
07-23 3497
最近学习了RISC-V架构的CPU设计，然后根据经典的五级流水线架构在Vivado上完成了一个简单的CPU，故开一个新坑记录该CPU的设计过程。该CPU实现了RVIM指令集，并可以搭建简单的SOC。这个CPU也有致命缺点，就是没有实现JTAG，无法进行调试，在后面会实现。目前CPU进度可搭建片上soc，已能够通过Vivado综合，各功能验证无误。注此软核仅用于学习交流，若要进行商用，请务必与作者本人联系！...
src_基于RISCV的流水线CPU设计_ricsv_五级流水线_源码
10-02
本设计在RICSV的基础上用Verilog语言实现了流水线CPU设计，项目中包含了五级流水线各自的源文件和testbench文件。
基于RISC-V五级流水线CPU实现的雷霆战机游戏
最新发布
2201_75854559的博客
07-09 1024
本工程是在FPGA开发板上，实现RISC-V五级流水线CPU，支持数据冒险，将分支指令判断提前至第二级，支持R型、I型、S型、B型、U型、J型指令。同时，手搓雷霆战机C语言代码，并转为汇编语言。下板后，在VGA上进行显示。
RISC-V五级流水线32位CPU：支持数据前递、CSR寄存器与中断控制器，含Dhrystone测试及2bit饱和分支预测，RISC-V五级流水线32位CPU的设计与实现：支持数据前递、CSR寄存器与
fSRQWxbmEA的博客
06-13 403
综上所述，Riscv五级流水线32位cpu是一款采用RISC-V指令集的处理器架构，具备了一些先进的特性，如数据前递、csr寄存器与中断控制器等。它还支持2bit饱和分支预测，并附带了相应的代码和文档，适合新手学习。在数据依赖关系导致的冒险情况下，数据前递可以将结果直接传递给需要使用该结果的指令，无需等待结果写回到寄存器，从而提高了处理器的性能。Riscv五级流水线32位cpu，systemverilog编写，指令集rv32i，支持数据前递，csr寄存器与中断控制器，可跑通dhrystone测试。
制作单周期CPU(代码)
WSQPoison的博客
04-21 4668
直接上代码SCPUmodule SCPU( CLK, Reset, CurPC, instcode ); input CLK; // 时钟信号 input Reset; // 置零信号 output [31:0] CurPC; // 当前指令的地址 output [31:0] instcode; // 指令寄存器中获取的指令码 wire ExtSel; //
单周期CPU实验之代码实现及模拟
Kiloveyousmile的博客
04-29 3445
单周期CPU代码实现。学习 了这么久，终于可以完整实现了单周期CPU了。以下是相关代码，供大家学习使用。
从零开始设计RISC-V处理器——五级流水线之控制冒险
qq_45677520的博客
05-10 1万+
系列文章目录 （一）从零开始设计RISC-V处理器——指令系统 （二）从零开始设计RISC-V处理器——单周期处理器的设计 （三）从零开始设计RISC-V处理器——单周期处理器的仿真 （四）从零开始设计RISC-V处理器——ALU的优化 （五）从零开始设计RISC-V处理器——五级流水线之数据通路的设计 （六）从零开始设计RISC-V处理器——五级流水线之控制器的设计 （七）从零开始设计RISC-V处理器——五级流水线之数据冒险 （八）从零开始设计RISC-V处理器——五级流水线之控制冒险 （九）从零开始设
机组大作业：基于RISC-V架构的45条指令单周期CPU设计
01-20
在本机组大作业中，我们将深入探讨基于RISC-V架构的单周期CPU设计。RISC-V，全称为“Reduced Instruction Set Computer - Version 5”，是一种开放源代码的指令集架构，旨在提供简单、高效且可扩展的计算平台。这个...
基于RISC-V的一个简单的五级流水线CPU设计源码+项目说明.zip
05-23
"基于RISC-V的一个简单的五级流水线CPU设计源码+项目说明.zip" 这个标题揭示了我们关注的核心内容是关于RISC-V架构的五级流水线CPU的设计。RISC-V是一种开放源代码指令集架构（ISA），它在近年来受到了广泛的关注，...
计算机系统课程设计：基于MIPS指令集架构的五段RISC流水线系统（Verilog源码）
01-13
流水线CPU与单周期和多周期CPU相比较，提高了指令的执行速度，改善了CPU的整体吞吐率，提高了CPU的性能。流水线CPU相对单周期CPU和多周期CPU，硬件设计上也更复杂，并且还有许多使流水线断流的因素。在设计中，重点...
单周期RISC-V架构CPU的设计
07-28
RISC-V是一种开放源码的指令集架构（ISA），其设计理念是精简指令集，旨在提供高效、低功耗的计算解决方案。下面，我们将深入探讨在设计一个单周期RISC-V CPU时需要考虑的关键知识点。 首先，我们要理解RISC-V ISA...
5级流水线riscv代码实现
06-04
riscv代码
支持RISC-V指令集，32位5级流水线，支持Flush与转发操作的CPU2
09-25
支持RISC-V指令集，32位5级流水线，支持Flush与转发操作的CPU
五级流水线CPU完整设计（包括control hazard和data hazard处理）
06-18
建议师弟师妹们还是要自己写，完整地理解好CPU设计的思路，不要直接在网上找到就抄。http://blog.csdn.net/c602273091/article/details/35883557 大家可以到师兄博客看一下hazard解决的思路分析。
riscv-cpu-verilog-code：大二上学期MS108大作业，verilog实现五级流水cpu
02-10
riscv-cpu-verilog-code：大二上学期MS108大作业，verilog实现五级流水cpu
从零开始设计RISC-V处理器——五级流水线之数据冒险
热门推荐
qq_45677520的博客
02-14 2万+
系列文章目录 （一）从零开始设计RISC-V处理器——指令系统 （二）从零开始设计RISC-V处理器——单周期处理器的设计 （三）从零开始设计RISC-V处理器——单周期处理器的仿真 （四）从零开始设计RISC-V处理器——ALU的优化 （五）从零开始设计RISC-V处理器——五级流水线之数据通路的设计 （六）从零开始设计RISC-V处理器——五级流水线之控制器的设计 （七）从零开始设计RISC-V处理器——五级流水线之数据冒险 （八）从零开始设计RISC-V处理器——五级流水线之控制冒险 （九）从零开始设
RISC五级流水线CPU设计verilog仿真
diaojiangxue的博客
03-29 2103
名称：RISC_v五级流水线CPU设计verilog仿真软件：Quartus/modelsim语言：verilog本文实现的CPU是一个五级流水线的精简版CPU(也叫PCPU，即pipeline)，包括IF(取指令)、ID(解码)、EX(执行)、MEM(内存操作)、WB(回写)。指令集：RISC指令集大小：2^5 = 32数据宽度：16bit数据内存：2^8×16bit = 256个16bit指令内存：2^8×16bit = 256个16bit通用寄存器：8×16bit。
基于五阶段流水线的RISC-V CPU模拟器实现
weixin_30832405的博客
03-26 6192
RISC-V是源自Berkeley的开源体系结构和指令集标准。这个模拟器实现的是RISC-V Specification 2.2中所规定RV64I指令集，基于标准的五阶段流水线，并且实现了分支预测模块和虚拟内存模拟。实现一个完整的CPU模拟器可以很好地锻炼系统编程能力，并且加深对体系结构有关知识的理解。在开始实现前，应当阅读并深入理解Computer Systems: A Program...
五级流水线CPU设计：基于RISC-V指令集实验
在设计基于RISC-V的五级流水线CPU时，需要考虑如何将RISC-V指令集的特性与流水线操作相协调，保证每个流水级能有效处理指令集中的指令。 知识点四：五级流水线中的数据冲突和控制冲突 在五级流水线中，可能会出现...
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值