简化的RSIC-CPU

最新推荐文章于 2024-06-16 19:14:37 发布
最新推荐文章于 2024-06-16 19:14:37 发布
阅读量1.2k 收藏 13
点赞数 3
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_43727437/article/details/104358363
版权
本文深入解析了RISC_CPU的内部结构与操作原理，详细介绍了时钟发生器、指令寄存器、累加器、算术逻辑运算单元、数据控制器、地址多路器、程序计数器和状态控制器等关键组件的运作机制。同时，阐述了RSIC_CPU的寻址方式、指令系统以及操作和时序，为理解RISC架构提供了全面视角。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

CPU是中央处理单元的缩写。计算机进行信息处理分为两个步骤：
（1）将数据和程序（即指令序列）输入到计算机的存储器中
（2）从第一条指令的地址起开始执行该程序，得到所需结果，结束运行。CPU的作用是协调并控制计算机的各个部件执行程序的的指令序列。使其有条不紊地进行。必须具备以下功能：
a）取指令：当程序已经在存储器中时，首先根据程序入口地址取出一条程序，为此要发出 指令地址以及控制信号。
b）分析指令：即指令译码。对当前取得的指令进行分析，指出它要求什么操作，并产生相应的操作控制命令。
c）执行指令：根据分析指令时产生的“操作命令”形成相应的操作控制信号序列，通过运算器，存储器及输入/输出设备执行，实现每条指令的功能，其中包括对运算的结果的处理以及下一条指令地址的形成。

CPU中应该包括以下部件：
（1）：算术逻辑运算部件
（2）：累加器
（3）：程序计数器
（4）：指令寄存器和译码器
（5）：时序和控制部件
RISC 即精简指令集计算机（Reduced Instruction Set Computer）的缩写。
RISC_CPU与一般的CPU的不同处在于：它的时序控制信号形成部件是用硬布线逻辑实现的而不是采用微程序控制的方式。所谓硬布线逻辑也就是用触发器和逻辑门直接连线所构成的状态机和组合逻辑，故产生控制序列的速度比用微程序控制方式快得多，因为这样做省去了读取微指令的时间。

本次的RSIC_CPU分为以下几个部件：
（1）时钟发生器
（2）指令寄存器
（3）累加器
（4）RSIC_CPU算术逻辑运算单元
（5）数据控制器
（6）状态控制器
（7）程序计数器
（8）地址多路器
各部件之间的相互操作关系则由状态控制器来控制。

1.1时钟发生器

在这里插入图片描述
在这里插入图片描述
fetch是clk的八分频信号。利用fetch的上升沿来触发CPU控制器开始执行一条命令，同时fetch信号还将控制地址多路器输出指令和数据地址。
clk1信号用作指令寄存器、累加器、状态控制器的时钟信号。
alu_clk用于触发算术逻辑单元。

module clk_gen (
	input clk,
	input reset,
	
	output wire clk1,
	output reg clk2,
	output reg clk4,
	output reg fetch,
	output reg alu_clk
);

reg [7:0] state;
parameter S1 = 8'b0000_0001,
		  S2 = 8'b0000_0010,
		  S3 = 8'b0000_0100,
		  S4 = 8'b0000_1000,
		  S5 = 8'b0001_0000,
		  S6 = 8'b0010_0000,
		  S7 = 8'b0100_0000,
		  S8 = 8'b1000_0000，
		  idle = 8'b0000_0000;
		  
assign clk1 = ~clk;

always @ (negedge clk) begin
	if(reset) begin
		clk2 <= 0;
		clk4 <= 1;
		fetch <= 0;
		alu_clk <= 0;
		state <= idle;
	end
	else begin
		case(state)
			S1 : begin
				clk2 <= ~clk2;
				alu_clk <= ~alu_clk;
				state <= S2;
				end
			S2 : begin
					clk2 <= ~clk2;
					clk4 <= ~clk4;
					alu_clk <= ~alu_clk;
					state <= S3；
				end
			S3 : begin
					clk2 <= ~clk2;
					state <= S4;
				end
			S4 : begin
					clk2 <= ~clk2;
					clk4 <= ~clk4;
					fetch <= ~fetch;
					state <= S5;
				end
			S5 : begin
					clk2 <= ~clk2;
					state <= S6;
				end
			S6 : begin
					clk2 <= ~clk2;
					clk4 <= ~clk4;
					state <= S7;
				end
			S7 : begin
					clk2 <= ~clk2;
					state <= S8;
				end
			S8 : begin
					clk2 <= ~clk2;
					clk4 <= ~clk4;
					fetch <= ~fetch;
					state <= S1;
				end
			idle : state <= S1;
			default : state <= idle;
		endcase
	end
end
			
endmodule

1.2指令寄存器

在这里插入图片描述
指令寄存器用于寄存指令。
指令寄存器的触发时钟是clk1,在clk1的正沿触发下，寄存器将数据总线送来的指令寄存到高八位或低八位寄存器中。但并不是每个clk1的上升沿都寄存数据总线数据，因为数据总线上有时传输指令有时传输数据。什么时候寄存什么时候不寄存由CPU的状态控制器load_ir信号控制。load_ir信号通过ena口输入到指令寄存器。复位后指令寄存器都被清零。
每条指令为2个字节，即16位，高三位是操作码，低13位是地址。（CPU的地址总线是13位，寻址空间就是8K），本数据总线是8位，所以每条指令取两次。先取高8位，后取低八位。而当前取的是高8位还是低8位，由变量state记录。state为0取的高8位，存入高的8位寄存器，同时将变量state置1.下次再寄存时，由于state为1，可知取的是低8位，存入到低8位寄存器中。

//指令寄存器
module register (
	input ena,
	input clk1,
	input rst,
	input [7:0] data,
	
	output reg [15:0] opc_iraddr
);

reg state;
always @ (posedge clk1) begin
	if(rst) begin
		opc_iraddr <= 16'b0000_0000_0000_0000;
		state <= 1'b0;
	end
	else if(ena) begin     //如果加载指令寄存器信号load_ir到来，分两个时钟每次8位加载到指令寄存器中，先高字节后低字节
		case(state)
			1'b0 : begin
					opc_iraddr[15:8] <= data;
					state <= 1'b1;
					end
			1'b1 : begin
					opc_iraddr[7:0] <= data;
					state <= 1'b0;
					end
			default : begin
					opc_iraddr[15:0] <= 16'bxxxx_xxxx_xxxx_xxxx;
					state <= 1'bx;
					end
		endcase
	end
	else 
		state <= 1'b0;
end

endmodule

1.3累加器

在这里插入图片描述
累加器用于存放当前的结果，它也是双目运算其中一个数据的来源。复位后，累加器的值就是零。当累加器通过ena口和收到来自CPU状态控制器load_acc时，在clk1时钟正跳变沿时就收到来自数据总线的数据。

//累加器
module accum (
	input clk1,
	input rst,
	input ena,
	input [7:0] data,
	
	output reg [7:0] accum
);

always @ (posedge clk1) begin
	if(rst) begin
		accum <= 8'b0000_0000;
	end
	else if(ena) begin
		accum <= data;
	end
end

endmodule

1.4算术运算器

在这里插入图片描述
算术逻辑运算单元根据输入的8中不同操作码可以实现相应的加、与、异或、跳转等8中基本操作运算。利用这几种基本运算可以实现很多种其他运算以及逻辑判断等操作。

//算术逻辑运算
module alu (
	input alu_clk,
	input [7:0] data,
	input [7:0] accum,
	input [2:0] opcode,
	
	output zero,
	output reg [7:0] alu_out;
);

parameter HLT = 3'b000,
		  SKZ = 3'b001,
		  ADD = 3'b010,
		  ANDD = 3'b011,
		  XORR = 3'b100,
		  LDA = 3'b101,
		  STO = 3'b110,
		  JMP = 3'b111;
		  
assign zero = !accum;
always @ (posedge alu_clk) begin
	case(opcode)
		HLT : alu_out <= accum;
		SKZ : alu_out <= accum;
		ADD : alu_out <= data + accum;
		ANDD : alu_out <= data & accum;
		XORR : alu_out <= data ^ accum;
		LDA : alu_out <= data;
		STO : alu_out <= accum;
		JMP : alu_out <= accum;
		default : alu_out <= 8'bxxxx_xxxx;
	endcase
end
		  
endmodule

1.5数据控制器

数据控制器的作用就是控制累加器数据的输出，由于数据总线是各种操作时传送数据的通道，不同的情况下传送不同的内容。有时要传输指令，有时要传送RAM区域或接口的数据。累加器的数据只有在需要向RAM区或端口写时才允许输出，否则应是高阻态，以允许其他部件使用数据总线。所以任何部件往总线上输出数据时，都需要一控制信号。而控制信号的开始与停止则是由CPU状态控制器输出的各信号控制决定。数据控制器何时输出累加器的数据则由状态控制器输出的控制信号datactl_ena决定。
在这里插入图片描述

//数据控制器
module datactl (
	input [7:0] in,
	input data_ena,
	output [7:0] data;
);


assign data = (data_ena) ? in : 8'bzzzz_zzzz;

endmodule

1.6地址多路器

在这里插入图片描述
地址多路器用于选择输出的地址是PC地址还是数据/端口地址。每个指令周期的前4个时钟周期用于从ROM中读取指令，输出的应该是PC地址。后4个时钟周期用于对RAM或者端口的读写，该地址由指令中给出。地址的选择输出信号是由时钟信号的8分频信号fetch提供。


//地址多路器
module adr(
	input [12:0] ir_addr,
	input [12:0] pc_addr,
	input fetch,
	
	output [12:0] addr
);

assign addr = fetch ? pc_addr : ir_addr;
endmodule

1.7程序计数器

程序计数器用于提供指令地址。以便读取指令，指令按照地址顺序存放在存储器中，有两种途径可以形成指令地址：其一是顺序执行的情况。其二是遇到要改变顺序执行程序的情况。例如JMP指令后，需要形成新的指令地址。
在这里插入图片描述
复位后指针为零，即每次CPU重启将从ROM的零地址开始读取指令并执行。每条指令执行完需要两个时钟。这时pc_addr已被增加2，指向下一条指令。（因为每条指令占两个字节）
如果执行的指令是跳转语句，这时CPU状态控制器将会输出load_pc信号，通过load口进入程序计数器。程序计数器pc_addr将装入目标值ir_addr，而不是增加2.

//程序计数器
module counter(
	input load,
	input clock,
	input rst,
	input [12:0] ir_addr,
	
	output reg [12:0] pc_addr
);

always @ (posedge clock or negedge rst) begin
	if(!rst) begin
		pc_addr <= 13'b0_0000_0000_0000;
	end
	else if(load) begin
		pc_addr <= ir_addr;
	end
	else 
		pc_addr <= pc_addr + 1;
end
endmodule

1.8状态控制器

在这里插入图片描述
状态控制器由两部分组成：
1）状态机（上图中的MACHINE部分）
2）状态控制器（上图中的MACHINECTL部分）
状态控制器接收复位信号rst，当rst有效时通过信号ena使其为零。输入到状态机中停止状态机的工作。

//状态控制器
module machinectl (
	input fetch,
	input rst,
	
	output reg ena
);

always @ (posedge fetch or posedge rst) begin
	if(rst) begin
		ena <= 0;
	end
	else begin
		ena <= 1;
	end
end

endmodule

状态机是CPU的控制核心，用于生产一些列的控制信号，启动或停止某些部件。CPU何时进行读指令读写I/O端口，RAM区等操作，都是由状态机来控制的。状态机的当前状态，由变量state记录，state的值就是当前这个指令周期中已经过的时钟数（从0开始）。
指令周期是由8个时钟周期组成，每个时钟周期都要完成固定的操作。
1）第0个时钟周期，因为CPU状态控制器的输出：rd和load_ir为高电平，其余均为低电平。指令寄存器寄存由ROM在送来的高8位指令代码。
2）第1个时钟周期，与上一个时钟周期相比只是inc_pc从0变为1故PC增加1，ROM送来的8位低指令代码，指令寄存器寄存该8位指令。
3）第2个时钟周期，空操作
4）第3个时钟周期，PC增1，指向下一条指令。若操作符为HLT，则输出信号HLT为高。如果操作符不为HLT，除了PC增加1之外，其他各控制线输出为0。
5）第4个时钟周期，若操作符为ADD，AND、XOR或LDA，读相应地址的数据，若为JMP，将目的地址送给程序计数器，若为ST0，输出累加器数据。
6）第5个时钟周期，若操作符是ANDD、ADD、XORR，算术运算器就应进行相应的操作。若为LDA，就把数据通过算术运算器送到累加器；若为SKZ，先判断累加器的值是不是为0，如果是0，则PC+1，否则就保持原值，若为JMP，锁存目的地址；若为STO，将数据写入地址处。
7）第6个时钟周期，空操作。
8）第7个时钟周期，若操作符为SKZ且累加器值为0，则PC值再增加1，跳过一条指令，否则PC无变化。

//CPU状态机
module machine(
	input clk1,
	input zero,
	input ena,
	input [2:0] opcode,
	
	output reg inc_pc,
	output reg load_acc,
	output reg load_pc,
	output reg rd,
	output reg wr,
	output reg load_ir,
	output reg datactl_ena,
	output reg halt
);

reg [3:0] state;
parameter HLT = 3'b000,
		  SKZ = 3'b001,
		  ADD = 3'b010,
		  ANDD = 3'b011,
		  XORR = 3'b100,
		  LDA = 3'b101,
		  STO = 3'b110,
		  JMP = 3'b111;

always @ (negedge clk1) begin
	if(!ena) begin
		state <= 3'b000;
		{inc_pc,load_acc,load_pc,rd} <= 4'b0000;
		{wr,load_ir,datactl_ena,halt} <= 4'b0000;
	end
	else 
		ctl_cycle;
end


//begin of task ctl_ctycle
task  ctl_cycle;
	begin
		case(state)
			3'b000 : begin     //load high 8bits in struction
						{inc_pc,load_acc_load_pc,rd} <= 4'b0001;
						{wr,load_ir,datactl_ena,halt} <= 4'b0100;
						state <= 3'b001;
					 end
			3'b001 : begin   //pc increased by one then load low 8bits instruction 
						{inc_pc,load_acc,load_pc,rd} <= 4'b1001;
						{wr,load_ir,datactl_ena,halt} <= 4'b0100;
						state <= 3'b010;
					 end
			3'b010 : begin //idle
						{inc_pc,load_acc,load_pc,rd} <= 4'b0000;
						{wr,load_ir,datactl_ena,halt} <= 4'b0000;
						state <= 3'b011;
					 end
			3'b011 : begin //next instrucion address setup 分析指令从这里开始
						if(opcode==HLT) begin   //指令为暂停HLT
							{inc_pc,load_acc,load_pc,rd} <= 4'b1000;
							{wr,load_ir,datactl_ena,halt} <= 4'b0001;
						end
						else begin
							{inc_pc,load_acc,load_pc,rd} <= 4'b1000;
							{wr,load_ir,datactl_ena,halt} <= 4'b0000;
						end
						state <= 3'b100;
					 end
			3'b100 : begin  //fetch oprand
						if(opcode==JMP) begin
							{inc_pc,load_acc,load_pc,rd} <= 4'b0010;
							{wr,load_ir,datactl_ena,halt} <= 4'b0000;
						end
						else if(opcode==ADD || opcode==ANDD || opcode==XORR || opcode==LDA) begin
							{inc_pc,load_acc,load_pc,rd} <= 4'b0001;
							{wr,load_ir,datactl_ena,halt} <= 4'b0000;
						end
						else if(opcode==STO) begin
							{inc_pc,load_acc,load_pc,rd} <= 4'b0000;
							{wr,load_ir,datactl_ena,halt} <= 4'b0010;
						end
						else begin
							{inc_pc,load_acc,load_pc,rd} <= 4'b0000;
							{wr,load_ir,datactl_ena,halt} <= 4'b0000;
						end
						state <= 3'b101;
					 end
			3'b101 : begin  //opreation
						if(opcode==ADD || opcode==ANDD || opcode==XORR || opcode==LDA) begin  //过一个时钟后与累加器的内容进行运算
							{inc_pc,load_acc,load_pc,rd} <= 4'b0101;
							{wr,load_ir,datactl_ena,halt} <=4'b0000;
						end
						else if(opcode==SKZ || zero == 1) begin
							{inc_pc,load_acc,load_pc,rd} <= 4'b1000;
							{wr,load_ir,datactl_ena,halt} <= 4'b0000;
						end
						else if(opcode==JMP) begin
							{inc_pc,load_acc,load_pc,rd} <= 4'b1010;
							{wr,load_ir,datactl_ena,halt} <= 4'b0000;
						end
						else if(opcode==STO) begin   //过一个时钟周期把wr变1就可写到ram中
							{inc_pc,load_acc,load_pc,rd} <=4'b0000;
							{wr,load_ir,datactl_ena.halt} <= 4'b1010;
						end
						else begin
							{inc_pc,load_acc,load_pc,rd} <= 4'b0000;
							{wr,load_ir,datactl_ena,halt} <= 4'b0000;
						end
						state <= 3'b110;
					 end
			3'b110 : begin  //idle
						if(opcode==STO) begin
							{inc_pc,load_acc,load_pc,rd} <= 4'b0000;
							{wr,load_ir,datactl_ena,halt} <= 4'b0010;
						end
						else if(opcode==ADD || opcode==ANDD || opcode==XORR || opcode==LDA) begin
							{inc_pc,load_acc,load_pc,rd} <= 4'b0001;
							{wr,load_ir,datactl_ena,halt} <= 4'b0000;
						end
						else begin
							{inc_pc,load_acc,load_pc,rd} <= 4'b0000;
							{wr,load_ir,datactl_ena,halt} <= 4'b0000;
						end
						state <= 3'b111;
					 end
			3'b111 : begin
						if(opcode==SKZ && zero==1) begin
							{inc_pc,load_acc,load_pc,rd} <= 4'b1000;
							{wr,load_ir,datactl_ena,halt} <= 4'b0000;
						end
						else begin
							{inc_pc,load_acc,load_pc,rd} <= 4'b0000;
							{wr,load_ir,datactl_ena,halt} <= 4'b0000;
						end
						state <= 3'b000;
					 end
			default : begin
						{inc_pc,load_acc,load_pc,rd} <= 4'b0000;
						{wr,load_ir,datactl_ena,halt} <= 4'b0000;
						state <= 3'b000;
					 end
		endcase
	end
endtask

endmodule

2.外围模块

需要有存储测试程序的ROM和装载数据的的RAM、地址译码器。

2.1地址译码器

地址译码器用于产生选通信号，选通ROM或RAM
FFFFH —1800H RAM
1800H ----0000H ROM

//地址译码器
module addr_decode (
	input [12:0] addr,
	output reg rom_sel,
	output reg ram_sel
);

always @ (addr) begin
	case(addr) 
		13'b1_1xxx_xxxx_xxxx : {rom_sel,ram_sel} <= 2'b01;
		13'b0_xxxx_xxxx_xxxx : {rom_sel,ram_Sel} <= 2'b10;
		13'b1_0xxx_xxxx_xxxx : {rom_sel,ram_sel} <= 2'b10;
		default : {rom_sel,ram_sel} <= 2'b00;
	endcase
end

endmodule

2.2ROM和RAM

ROM用于装载测试程序，可读不可写
RAM用于存放数据，可读可写


//RAM
module (
	input [9:0] addr,
	input ena,
	input read,
	input write,
	inout [7:0] data
);

reg [7:0] ram [10'h3ff:0];

assign data = (read && ena) ? ram[addr] : 8'hzzzz_zzzz;

always @ (posedge write) begin
	ram[addr] <= data
end
endmodule

//ROM
module rom (
	input [12:0] addr,
	input read,
	input ena,
	output [7:0] data
);
reg [7:0] rom [13'h1fff:0];

assign data = (read && ena) ? rom[addr] : 8'hzzzz_zzzz;


endmodule

3.RSIC_CPU操作和时序

一个微机操作为了完成自身的功能，需要CPU执行许多操作，以下是RSIC_CPU的主要操作：
（1）系统的复位和启动操作
（2）总线读操作
（3）总线写操作

3.1系统的复位和启动操作

RSIC_CPU的复位和启动操作是通过rst引脚的信号触发执行的。当rst进入·高电平，RSIC_CPU就会结束现行操作。并且只要rst停留在高电平状态CPU就处于复位状态。在复位状态，CPU各内部寄存器都被设为初值，全部为零。数据总线为高阻态，地址总线为0000H，所有的控制信号均为无效状态。rst回到低电平之后，接着到来的第一个fetch上升沿将启动RSIC_CPU开始工作。从ROM的0000H处开始读指令并执行相应的操作。
在这里插入图片描述

3.2总线读操作

每个指令周期的前4个时钟周期用于读指令，在第3.5个周期处，存储器或者端口地址就输出到地址总线上，第4-6个时钟周期，读信号rd有效，数据送到数据总线上，以备累加器锁存，或参与算术、逻辑运算。第7个时钟周期，读信号无效，第7.5个周期，地址总线输出PC地址，为下一个指令做好准备。

3.3写总线操作

每个指令周期在第3.5个时钟周期处，写地址就建立了，第4个时钟周期输出数据，第5个时钟周期输出写信号。至第6换个时钟周期结束，数据无效，第7.5个时钟地址输出为PC地址，为写一个指令做好准备。

4.RSIC_CPU的寻址方式和指令系统

RSIC_CPU的指令格式一律为：
在这里插入图片描述
它的指令系统仅由8条指令组成。
1）HLT
停机操作。该操作将空一个指令周期，即8个时钟时钟周期。
2）SKZ
为零跳过下一条语句。该操作先判断当前alu中的结果是否为0，若是0就跳过下一条语句，否则继续执行。
3）ADD
相加。该操作将累加器中的值与地址所指的存储器或端口的数据相加，结果扔送回累加器中。
4）AND
相与。该操作将累加器的值与地址所指的存储器或端口的数据想与，结果仍送回累加器中。
5）XOR
异或。该操作将累加器的值与指令给出地址的数据异或，将结果仍送回累加器中。
6）LDA
读数据。该操作将指令中给出地址的数据放到累加器中
7）STO
写数据。该操作将累加器的数据放到指令给出的地址。
8）JMP
无条件跳转语句。该操作将跳转至指令给出的目的地址，继续执行。
RISC_CPU是8位微处理器，一律采用直接寻址方式，即数据总是放在存储器中，寻址单元的地址由指令直接给出。这是最简单的寻址方式。

在这里插入图片描述

//---------------------CPU_TOP---------------------------
`include "clk_gen.v"
`include "accum.v"
`include "addr.v"
`include "alu.v"
`include "machine.v"
`include "counter.v"
`include "machinectl.v"
`include "register.v"
`include "datactl.v"
module cpu(
	input clk,
	input reset,
	output rd,
	output wr,
	output [12:0] addr,
	output halt,
	inout [7:0] data
);

wire clk;
wire reset;
wire halt;
wire [7:0] data;
wire [12:0] addr;
wire rd;
wire wr;
wire clk1;
wire fetch;
wire alu_clk;
wire [2:0] opcode;
wire [12:0] ir_addr;
wire [12:0] pc_addr;
wire [7:0] alu_out;
wire [7:0] accum;
wire zero;
wire inc_pc;
wire load_acc;
wire load_pc;
wire load_ir;
wire data_ena;
wire contr_ena;

clk_gen clk_gen_inst (
						.clk(clk),
						.clk1(clk1),
						.fetch(fetch),
						.alu_clk(alu_clk),
						.reset(reset)
						);
						
register register_inst (
						.clk1(clk1),
						.data(data),
						.ena(load_ir),
						.rst(reset),
						.opc_iraddr({opcode,ir_addr})
						);


accum auum_inst (
				.data(alu_out),
				.ena(load_acc),
				.clk1(clk1),
				.rst(reset),
				.accum(accum)
				);

alu alu_inst (
				.data(data),
				.accum(accum),
				.alu_clk(alu_clk),
				.opcode(opcode),
				.alu_out(alu_out),
				.zero(zero)
			);

machinectl machinectl_inst (
							.ena(contr_ena),
							.fetch(fetch),
							.rst(reset)
							);

machine machine_inst (
						.inc_pc(inc_pc),
						.load_acc(load_acc),
						.load_pc(load_pc),
						.rd(rd),
						.wr(wr),
						.load_ir(load_ir),
						.clk1(clk1),
						.datactl_ena(data_ena),
						.halt(halt),
						.zero(zero),
						.ena(contr_ena),
						.opcode(opcode)
					 );	

datactl datactl_inst (
						.in(alu_out),
						.data_ena(data_ena),
						.data(data)
					);

adr adr_inst (
				.fetch(fetch),
				.ir_addr(ir_addr),
				.pc_addr(pc_addr),
				.addr(addr)
			);

counter counter.inst (
						.ir_addr(ir_addr),
						.load_pc(load_pc),
						.clock(inc_pc),
						.rst(reset),
						.pc_addr(pc_addr)
					);			

endmodule

这个设计的最大难点就是要把各个指令的时间要匹配好，一个指令周期，要把该做的事情都做好。

day day learn
关注
【RISC-V CPU Debug 专栏 1.1 -- RISC-V debug 规范】
CodingCos的博客
11-27 581
这种调试架构使得 RISC-V 平台能够灵活地支持各种复杂的调试场景，满足从低级硬件调试到操作系统级别调试的需求。RISC-V 的调试支持架构由多个组件组成，用于实现对硬件的全面调试功能。以下是 RISC-V 调试框架的主要组件和它们的作用说明。RISC-V 调试规范为处理器设计者和开发者提供了强大的工具，用于多种复杂调试场景，提高了调试效率，并简化了调试过程。RISC-V 调试规范为 RISC-V 处理器提供了一套标准化的调试接口和功能，旨在支持多种调试用例。以下是 RISC-V 调试规范的详细介绍。
RISC_CPU完整代码
11-30
基于FPGA的嵌入式CPU开发，verilog编写，完全仿真可用
浅谈RISC CPU（精简指令集处理器）
首席技术总监的专栏
10-24 8568
目前的处理器中，一般分为CISC和RISC两大系列，CISC（复杂指令集处理器）中常用的指令集只占源代码的20%，剩余的80%不常用。 为了改变这种不合理，出现了RISC即精简指令集处理器。其通道中只包含最有用的指令，确保数据通道快速执行每一条指令，使CPU硬件结构设计变得更为简单，尽量使用单周期指令，便于流水线操作执行。 今天我们再深入的聊一聊RISC CPU，那么首先什么是CPU？ CPU是什么 CPU是Central Processing Unit（中央处理单元）的缩写，被称为计算机的大脑。首
计算机体系架构（3）RISC CPU
新芯设计的博客
10-06 2916
计算机体系架构（3）RISC CPU
RISC  CPU
m0_57431551的博客
07-16 790
RISC机器的特点 RISC概括的三个基本要素： 一个有限的简单的指令系统； CPU配备大量的通用寄存器； 强调对指令流水线的优化。 基于三要素的RISC机器的特征如下： 使用等长指令，目前的典型长度是4B； 寻址方式少且简单，一般为二三种，最多不包括不超过4种，绝不会出现存储器间接寻址方式；只有取数指令、存数指令访问存储器。指令中最多出现RS型指令，绝不出现SS型指令； 指令系统中的指令数目一般少于100种，指令格式一般少于4种； 指令功能简单，控制器多采用硬布线方式，以期更快的执行速度； 平均而言，.
从零认识cpu之RISC-V架构（三）构建一个单周期CPU详细教程
最新发布
weixin_47138614的博客
06-16 3322
构建一个简单的单周期risc-v处理器
RSIC-V单周期CPU设计代码，实现了17种指令
12-15
单周期CPU设计的简化特性使其更适合于低功耗和资源有限的环境。 在实现这些指令时，CPU的核心部件包括：算术逻辑单元（ALU）用于执行算术和逻辑运算，寄存器文件用于暂存数据，控制单元用于解码指令并生成控制信号...
RSIC-V相关资料（指令集（ISA）详细介绍、指令集发展报告、计算机组织和设计RISC-V版）
01-09
在CPU设计方面，RISC-V简化了指令格式，减少了指令数量，提高了指令执行效率。与传统的复杂指令集（CISC）相比，RISC-V通常需要更少的晶体管，功耗更低，更适合低功耗设备。同时，由于RISC-V的开放源码性质，它促进...
简化RISC_CPU设计
m0_58413328的博客
11-22 1297
一、什么是CPU？ CPU 即中央处理单元的英文缩写，它是计算机的核心部件。计算机进行信息处理可分为两个步骤： 将数据和程序（即指令序列）输入到计算机的存储器中。 从第一条指令的地址起开始执行该程序，得到所需结果，结束运行。CPU的作用是协调并控制计算机的各个部件执行程序的指令序列，使其有条不紊地进行。因此它必须具有以下基本功能： 取指令：当程序已在存储器中时，首先根据程序入口地址取出一条程序，为此要发出指令地址及控制信号。 分析指令：即指令译码。是...
《计算机组成与设计 RSIC-V版》阅读笔记——计算机抽象及相关技术
hhh_YangGe的博客
12-11 540
第一章：计算机抽象及相关技术 介绍相关概念和定义；介绍软件和硬件的组成部分；介绍如何评估性能和功耗；介绍技术发展方向；打基础似的一章 引言： 计算应用分类 个人计算机PC --> 个人移动设备（Perisonal Mobile Device, PMD） 服务器（更强调可靠性，故障的代价高） --> 云计算(软件即服务，SaaS) 嵌入式计算机（特定的需求，通常人们对故障的容忍度较低） 软件开发思维： 减少程序占用的内容空间以加速程序运行 --> 利用处理器的并行性
计算机组成原理（4.3）—— MIPS指令系统（RSIC）
热门推荐
佚失的诗篇
08-16 1万+
前一篇文章分析了指令系统（ISA）的设计方法，这里以MIPS指令系统为例进行分析 前文链接：计算机组成原理（4.1）—— 指令系统设计 文章目录一、MIPS架构基础1. 寄存器数据指定（1）MIPS架构中的寄存器安排（2）寄存器名称、编号和功能2. 存储器数据指定二、操作数类型和表示方式1. 操作数类型2. 操作数表示方式三、指令格式1. R型指令2. I型指令3. J型指令4. 汇编指令和机器码指令字示例（1）MIPS汇编示例（2）机器码指令字示例（3）汇编和反汇编四、寻址方式1. R型指令的寻址2.
RSIC-V“一芯”学习笔记（一）——概述
河海大学研究生在读的学习笔记
01-12 1192
考研的文章和资料之后想写的时候再写怕趴。
RSIC设计思想
z1179675084的专栏
12-17 1291
RSIC设计思想主要由以下四个设计准则来实现      1指令集——RSIC处理器减少了处理指令种类。RSIC的指令种类只提供简单的操作，是一个周期就可以执行一条指令，每条指令长度都是固定的，允许流水线在当前指令阶段去读取下一条指令     2流水线——指令的处理过程被拆分为几个更小的、能够被流水线并行执行的单元，理想情况下，流水线每周期前进一步，可获得更高的吞吐率。      3寄存器——
RSIC-V --第一印象
weixin_45090533的博客
06-27 884
RSIC与RSIC-V指令是什么？ RSIC实际上它就是一种精简指令处理器。 RISC缩写-Reduced Instruction Set Computer， 精简指令集计算机 起源：美国加州大学伯克利分校 课题研究产物 创立者：David Patterson教授及其团队 (图片来源于网络，已经获得了图灵奖！如有侵权，可联系删除) 放在这里只是让大家有个直观印象，至少我是想知道究竟是怎么样聪明的人，改变了世界？并表示个人的万分钦佩与由衷感谢，毕竟技术属于全人类，技...
RSIC-V——指令集spec阅读笔记——用户级
知识，既贵，又便宜。
07-01 5198
riscv用户指令集阅读记录
RSIC-V——指令集spec阅读笔记——向量扩展0.9
知识，既贵，又便宜。
11-09 1万+
rvv 是risc-v指令集中的向量扩展。
操作码4：逻辑运算
u012447768的专栏
02-25 674
Java虚拟机的逻辑运算只要针对int和long类型 ishl 向左对int类型进行移位操作 ishr 向右对int类型进行移位 >>(向右平移，符号为正，高位补0，符号位负，高位补1） iushr向有对int类型进行逻辑移位操作 ，（无论正负，在高位都补0） lshl 向左对long类型值进行移位操作 lshr lushr 位逻辑运算 iand 对两个i
RISC-CPU设计（七）：算术运算器模块（ALU）设计
weixin_43701504的博客
11-03 2047
1.算术运算器模块的作用 算术运算器模块根据输入的8种不同操作码（来自指令寄存器输出的最高三位）分别实现对应的加、与、异或、跳转等基本操作运算。利用这几种基本运算可以实现很多种其它运算以及逻辑判断等操作。 2.模块端口图 3.端口功能描述 DATA和ACCUM分别是来自累加器和数据控制器的输出，OPCODE是来自指令寄存器输出的高三位指令信号，由时钟控制模块产生的alu_clk信号控制下，实现八种指令对应的不同操作，由ALU_OUT端口...
汇编语言基础知识
weixin_42277902的博客
07-03 4496
是很多文章的总结，不太记得来源了
全面解析FPGA RSIC CPU设计文档与源码
RSIC CPU是一种微处理器架构，其特点是拥有简化的指令集和高效的指令处理。RSIC（Reduced Instruction Set Computer）架构简化了处理器的设计，使其运行速度更快，效率更高。与之相对的复杂指令集计算机（CISC）如...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值