基于verilog的多周期处理器设计

最新推荐文章于 2024-05-21 10:00:41 发布
最新推荐文章于 2024-05-21 10:00:41 发布
阅读量2.6k 收藏 32
点赞数 3
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43534451/article/details/106604281
版权

一、计算机的组成结构

1.五个组成部件：数据通路,控制器,存储器,输入输出设备
2.处理器(CPU):数据通路 + 控制器
什么是数据通路？
指令执行过程中,数据所经过的路径,包括路径中的部件。它是指令的执行部件
控制器的功能是什么？
对 指令进行译码,生成指令对应的控制信号,控制数据通路的动作。能对执行部件发出控制信号,是指令的控制部件。

二、MIPS指令的执行过程

1.R-type指令
取指、译码+取数、执行、写回
2.I-type指令
立即数运算/逻辑运算指令：取指、译码+取数、执行、写回(寄存器文件)
比较指令：取指、译码+取数、执行（PC更新）
Store指令：取指、译码+取数、执行（计算写回地址）
Load指令：取指、译码+取数、执行（计算读出的地址）、访存、写回（寄存器文件）
3.J-type指令
取指、译码+取数 （PC更新）

三、多周期处理器

主要思想：把指令的执行分成多个阶段,每个阶段在一个时钟周期内完成,
3.1尽量分成大致相等的若干阶段（取指、译码+取数、执行、访存、写回）
3.2规定每个阶段最多完成1次访存或寄存器堆读/写或ALU
3.3时钟周期以最复杂阶段花费时间为准
每步设置存储元件，每部执行结果都在下个时钟开始保存到相应单元
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
多周期处理器数据通路的代码如下

module MutipleDataPath(
   input clk,
   input rstn,
   input PcWr,
  // input IoD,
   input PcwrCond,
   input MemWr,
   input IRWr,
   input RegDst,
   input RegWr,
   input ALUSelA,
   input[1:0] ALUSelB,
   input BrWr,
   input [1:0] PcSource,
   input MDRWr,
   input MemtoReg,
   input ExtOp,
   input[3:0] AluOp,
   output   [31:0] instruction
   );

 
reg  [31:0]   IR;
reg  [31:0]   MDR;
reg  [31:0]   A,B;
reg  [31:0]  Branch;
reg  [31:0]  PC;
reg  [31:0] PcNext;
wire PCen;
wire [31:0] DA;
reg [31:0] DB;
wire [31:0] zero;
wire overflow;
wire[31:0] ALUResult;
assign instruction = IR;

 always@(*) begin
	   case(PcSource)
			2'b00: PcNext = {PC[31:28],IR[25:0],2'b00};
			2'b01: PcNext = ALUResult;
			2'b10: PcNext = Branch;
			2'b11: PcNext = A;
			default: PcNext = 32'd0;
	   endcase
   end
   
   
   assign PCen = PcWr | ((PcwrCond & (&zero)) | (PcwrCond & (~(&zero))));
   
	 always @(posedge clk or negedge rstn) begin
		 if(~rstn)
			PC <= 32'd0;
		 else if(PCen)
			PC <= PcNext;
	 end
 
    wire [31:0] MemAddr;
    wire [31:0] RdData1;
	 wire [31:0] RdData2;
    assign MemAddr = ALUResult; 
//(IoD)?ALUResult:PC
/*
	RamNoDelay Mem(
			.clk(clk),
			.wen(MemWr),
			.WrAddr(MemAddr),
			.WrData(B),
			.RdAddr(MemAddr),
			.RdData(RdData)
	);
	*/
	RamNoDelay Mem(
	    .clk(clk),
	    .wen(MemWr),
	    .WrAddr(MemAddr),
	    .WrData(B),
	    .RdAddr1(MemAddr),
	    .RdAddr2(PC),
	    .RdData1(RdData1),
	    .RdData2(RdData2)
);
	
	always@(posedge clk or negedge rstn) begin
		if(~rstn) 
		   IR <=32'd0;
		else if(IRWr)
		   IR <= RdData2; 
	end

	always@(posedge clk or negedge rstn) begin
	if(~rstn) 
	   MDR<=32'd0;
	else if(MDRWr)
       MDR <= RdData1;
	end
	
	wire [4:0] Rs;
	wire [4:0] Rt;
	wire [4:0] Rd;
	wire [4:0] shift;
	wire [15:0] imme;
	assign Rs= IR[25:21];
	assign Rt= IR[20:16];
	assign Rd= IR[15:11];
	assign shift=IR[10:6];
	assign imme= IR[15:0];
	
	wire [4:0]  Rw;
	wire [31:0] BusA, BusB;
	wire [31:0] Dw;
	wire Rwen;
	assign Rw=(RegDst)?Rd:Rt;
	assign Dw=(MemtoReg)?MDR:ALUResult;
	assign Rwen =  ~overflow & RegWr;
	
	
	dflipflop RegisterFile(
	.clk(clk),
	.Ra(Rs),
	.Rb(Rt),
	.Rw(Rw),           //要写入的目的寄存器的地址
	.Wen(Rwen),
	.BusA(BusA),
	.BusB(BusB),    
	.BusW(Dw)          //要写入的32位数据
	);
	

	
	
always@(posedge clk or negedge rstn) begin
      if(~rstn)
	     A <= 32'd0;
      else 
	     A <= BusA;
end

always@(posedge clk or negedge rstn) begin
	if(~rstn)
	  B <= 32'd0;
	else 
	  B <= BusB;
end 

wire [31:0] ExtResult;
assign ExtResult = (ExtOp)? {{16{imme[15]}},imme}:{16'd0,imme};


assign DA= (ALUSelA)?A:PC;

	always@(*)begin
		case(ALUSelB)
			2'b00: DB = B;
			2'b01: DB = 3'b100;
			2'b10: DB = ExtResult;
			2'b11: DB = ExtResult << 2;
		endcase
	end
	
	alu alu(
		.alu_DA(DA),
		.alu_DB(DB),
		.alu_CTL(AluOp),
		.alu_SHIFT(shift),
		.alu_ZERO(zero),
		.alu_Overflow(overflow),
		.alu_DC(ALUResult)
	);
	

	
	always@(posedge clk or negedge rstn) begin
		if(~rstn)
		   Branch <=32'd0;
		else if(BrWr) 
		   Branch <= ALUResult;
	end

endmodule
 

module RamNoDelay(
  input clk,
  input wen,
  input [31:0] WrAddr,
  input [31:0] WrData,
  input [31:0] RdAddr1,
  input [31:0] RdAddr2,
  output [31:0] RdData1,
  output [31:0] RdData2
);
   reg [31:0] rom [255:0];
   initial begin
     $readmemh("F:/work/digital_system_practise/Multiple_data_path/rtl/inst_rom.data",rom);
  end 
 reg [31:0] ram [255:0];
 always@(posedge clk)begin
   if(wen)
     ram[WrAddr] <= WrData;
 end 
 
 assign RdData1 = ram[RdAddr1];
 assign RdData2 = rom[RdAddr2];

endmodule


module dflipflop(
             input          clk,
				 input  [4:0]  	Ra,
				 input  [4:0]   Rb,
				 input  [4:0]   Rw,
				 input          Wen,
				 output [31:0]  BusA,
				 output [31:0]  BusB,
				 input  [31:0]  BusW
);
				 
				 reg    [31:0]DataReg[31:0];			 
	

	            always@(posedge clk)
		        begin	
			         if(Wen & Rw!=5'd0)
			        	DataReg[Rw] <= BusW;
		        end		
	
	            assign BusA = (Ra==5'd0)?32'd0:DataReg[Ra];
	            assign BusB = (Rb==5'd0)?32'd0:DataReg[Rb];
		
endmodule


module alu(
  input [31:0] alu_DA,
  input [31:0] alu_DB,
  input [3:0] alu_CTL,
  input [4:0] alu_SHIFT,
  output [31:0] alu_ZERO,
  output alu_Overflow,
  output reg [31:0] alu_DC 
);
    
  /******************general ctr ****************************/
  wire SUBctr;
  wire SIGctr;
  wire Ovctr;
  wire [1:0] Opctr;
  wire [1:0] Logicctr;
  wire [1:0] Shiftctr;
  
  assign SUBctr = ((~alu_CTL[3]) &  ~alu_CTL[2] & alu_CTL[1])|(alu_CTL[3] & ~alu_CTL[2]);
  assign Opctr = alu_CTL[3:2];
  assign Ovctr = (alu_CTL[0] & ~alu_CTL[3] & ~alu_CTL[2])|(alu_CTL[3] & ~alu_CTL[2] & ~alu_CTL[1] & alu_CTL[0]);
  assign SIGctr = alu_CTL[0];
  assign Logicctr = alu_CTL[1:0];
  assign Shiftctr = alu_CTL[1:0];

  /*****************logic op****************************/
  reg [31:0] logic_result;
  
  always@(*)begin
    case(Logicctr)
	   2'b00:logic_result = alu_DA & alu_DB;
	   2'b01:logic_result = alu_DA | alu_DB;
	   2'b10:logic_result = alu_DA ^ alu_DB;
	   2'b11:logic_result = ~(alu_DA | alu_DB);
	endcase
  end
  
  /********************shift op****************************/
  wire [31:0] shift_result;
  
  Shifter Shifter(
      .alu_DB(alu_DB),
      .ALUSHIFT(alu_SHIFT),
      .Shiftctr(Shiftctr),
	   .shift_result(shift_result)
  ); 
  
  /************************add sub op*********************************/
  wire [31:0] BIT_M,XOR_M;
  wire ADD_carry,ADD_OverFlow;
  wire [31:0] ADD_result;
  wire [31:0] comp_M;
  assign BIT_M = {32{SUBctr}};
  assign XOR_M = (alu_DB[31] && SUBctr)?{1'b0,alu_DB[30:0]}:BIT_M ^ alu_DB;
  assign comp_M = (alu_DB[31] && SUBctr)?XOR_M: XOR_M + SUBctr;
  assign alu_Overflow = ADD_OverFlow & Ovctr;
  assign {ADD_carry,ADD_result} = alu_DA + comp_M;
  assign  ADD_OverFlow = (alu_DA[31] && comp_M[31] && !ADD_result[31]) +
                          (!alu_DA[31] && !comp_M[31] && ADD_result[31]); 
  assign alu_ZERO = (|ADD_result)?32'h0000_0000:32'hffff_ffff;
  /****************************slt op****************************/
  wire [31:0] SLT_result;
  wire LESS_M1,LESS_M2,LESS_S,SLT_M;
  
  assign LESS_M1 = ADD_carry ^ SUBctr;
  assign LESS_M2 = ADD_OverFlow ^ ADD_result[31];
  assign LESS_S = (SIGctr == 1'b0)?LESS_M1:LESS_M2;
  assign SLT_result = (LESS_S)?32'hffff_ffff:32'h0000_0000;
  
  /****************************ALU_result***************************/
  always@(*)
  begin
    case(Opctr)
	  2'b00:alu_DC = ADD_result;
	  2'b01:alu_DC = logic_result;
	  2'b10:alu_DC = SLT_result;
	  2'b11:alu_DC = shift_result;	  
	endcase
  end
 
endmodule 
  

module aluControl(
   input [5:0] func,
   output [3:0] aluOp
);

wire add = (func == 6'b100000);
wire addu = (func == 6'b100001);
wire sub = (func == 6'b100010);
wire subu = (func == 6'b100011);
wire and1 = (func == 6'b100100);
wire or1 = (func == 6'b100101);
wire xor1 = (func == 6'b100110);
wire nor1 = (func == 6'b100111);
wire sltu = (func == 6'b101011);
wire slt = (func == 6'b101010);
wire sll = (func == 6'b000000);
wire srl = (func == 6'b000010);
wire sra = (func == 6'b000011);


assign aluOp = ({4{add}} & 4'b0001) |
               ({4{addu}} & 4'b0000) |
			   ({4{sub}} & 4'b0011) |
			   ({4{subu}} & 4'b0010) |
			   ({4{and1}} & 4'b0100) |
			   ({4{or1}} & 4'b0101) |
			   ({4{xor1}} & 4'b0110) |
			   ({4{nor1}} & 4'b0111) |
			   ({4{sltu}} & 4'b1000) |
			   ({4{slt}} & 4'b1001) |
			   ({4{sll}} & 4'b1100) |
			   ({4{srl}} & 4'b1101) |
			   ({4{sra}} & 4'b1110);
			   

				
endmodule

控制器模块的代码下：

module MultipleControl(
   input clk,
   input rstn,
   output PcWr,
	//output IoD,
	output PcWrCond,
   output MemWr,
   output IRWr,
   output RegDst,
   output RegWr,
   output  reg ALUSelA,
   output  reg [1:0] ALUSelB,
   output BrWr,
   output reg [1:0] PcSource,
   output MDRWr,
   output MemtoReg,
   output reg ExtOp,
   output reg [3:0] AluOp,
   input [31:0] instruction   
);

  reg [3:0] nstate;
  reg [3:0] state;
  
  parameter IFetch = 4'b0000,
            RFetch = 4'b0001,
			   BrFinish = 4'b0010,
			   Jfinish = 4'b0011,
				Jrfinish = 4'b0100,
			   OriExec = 4'b0101,
			   OriFinish = 4'b0110,
			   Rexec = 4'b0111,
			RFinish = 4'b1000,
			MemAdr = 4'b1001,
			swFinish = 4'b1010,
			MemFetch = 4'b1011,
			lwFinish = 4'b1100;
			
			//wire [3:0] Aluctr;
			wire [5:0] op = instruction[31:26];
			wire [5:0] func = instruction[5:0];
			wire jr = ((op == 6'b000000) && (func == 6'b001000));
			
			
			wire ori = (op == 6'b001101);
			//wire andi = (op == 6'b001100);
			wire lw = (op == 6'b100011);
			wire sw = (op == 6'b101011);
			wire beq = (op == 6'b000100);
			wire bne = (op == 6'b000101);
			wire j = (op == 6'b000010);
			//wire addi = (op == 6'b001000);
			wire R_type = (op == 6'b000000);
			wire instrl = ori;
			wire ls = lw | sw;
			
			always@(*)begin
			    case(state)
				  IFetch:nstate = RFetch;
				     RFetch:if(beq || bne) nstate = BrFinish;
					   else if(j) nstate = Jfinish;
					      else if(instrl) nstate = OriExec;
						  else if(R_type) nstate = Rexec;
						  else if(ls) nstate = MemAdr;
						  else if(jr) nstate = Jrfinish; 
						  else nstate = IFetch;
				  BrFinish: nstate = IFetch;
				  Jfinish:  nstate = IFetch;
				  Jrfinish: nstate = IFetch;
				  Rexec:nstate = RFinish;
				  RFinish:nstate = IFetch;
				  OriExec:nstate = OriFinish;
				  OriFinish:nstate = IFetch;
				  MemAdr: if(lw) nstate = MemFetch;
				      else nstate = swFinish;
					swFinish:nstate = IFetch;
					MemFetch:nstate = lwFinish;
				lwFinish:nstate = IFetch;
				default:nstate = IFetch;
				  endcase
			end
			
   wire [3:0] aluOp1 = ({4{ori}} & 4'b0101);
/*	|
                       ({4{andi}} & 4'b0100) |
					   ({4{addi}} & 4'b0001);
	*/

   wire [3:0]aluOp2;
					   
	aluControl aluControl(
			 .func(func),
			 .aluOp(aluOp2)
			 );

			 
	assign PcWr = (state == IFetch) | (state == Jfinish) | (state == Jrfinish);
	//assign IoD = (state == MemAdr) | (state == swFinish) | (state == MemFetch)|(state == lwFinish);
	assign PcWrCond = (state == BrFinish);
	assign MemWr = (state == swFinish);
	assign IRWr = (state == IFetch);
	assign RegDst = (state == Rexec) | (state == RFinish);
	assign RegWr = (state == RFinish) | (state == OriFinish) | (state == lwFinish);
	assign BrWr = (state == RFetch);
	assign MemtoReg = (state == lwFinish);
	assign MDRWr = (state == MemFetch);
	
	always@(posedge clk or negedge rstn)begin
	  if(!rstn)
	     state <= IFetch;
	  else 
	     state <= nstate;
	end 
	
	always@(*)begin
   case(state)
		
	       IFetch:  
			       begin 
			         ALUSelA = 1'b0; ALUSelB = 2'b01; PcSource = 2'b01; ExtOp = 1'b0; AluOp = 4'b0000;
						end 
		   RFetch:    
			     begin
		      	ALUSelA = 1'b0;ALUSelB = 2'b11;PcSource = 2'b01;ExtOp = 1'b1;AluOp = 4'b0000;
					end
	       BrFinish:  begin
			      ALUSelA = 1'b1;ALUSelB = 2'b00;PcSource = 2'b10;ExtOp = 1'b0;AluOp = 4'b0010;
					end
		   Jfinish:    
			    begin
			    ALUSelA = 1'b0;ALUSelB = 2'b00;PcSource = 2'b00;ExtOp = 1'b0;AluOp = 4'b0000;
				 end
			  Jrfinish:    
			    begin
			    ALUSelA = 1'b0;ALUSelB = 2'b00;PcSource = 2'b11;ExtOp = 1'b0;AluOp = 4'b0000;
				 end
		   OriExec:   
			      begin
		      	ALUSelA = 1'b1;ALUSelB = 2'b10;PcSource = 2'b01;ExtOp = 0;AluOp = aluOp1;
					end
		   OriFinish: 
			      begin
		       	ALUSelA = 1'b1;ALUSelB = 2'b10;PcSource = 2'b01;ExtOp = 0;AluOp = aluOp1;
					end 
		   Rexec:
			   begin
			   ALUSelA = 1'b1;ALUSelB = 2'b00;PcSource = 2'b01;ExtOp = 1'b0;AluOp = aluOp2;
				end 
		   RFinish:
            begin
			   ALUSelA = 1'b1;ALUSelB = 2'b00;PcSource = 2'b01;ExtOp = 1'b0;AluOp = aluOp2;
	         end 
		   MemAdr:
			   begin
			   ALUSelA = 1'b1;ALUSelB = 2'b10;PcSource = 2'b01;ExtOp = 1'b1;AluOp = 4'b0000;
				end 
		   swFinish:
			  begin
			  ALUSelA = 1'b1;ALUSelB = 2'b10;PcSource = 2'b01;ExtOp = 1'b1;AluOp = 4'b0000;
			  end
		   MemFetch:
			   begin
			   ALUSelA = 1'b1;ALUSelB = 2'b10;PcSource = 2'b01;ExtOp = 1'b1;AluOp = 4'b0000;
				end
		   lwFinish: begin 
			    ALUSelA = 1'b1;ALUSelB = 2'b10;PcSource = 2'b01;ExtOp = 1'b1;AluOp = 4'b0000;
		     end
			default: begin ALUSelA = 1'b0;ALUSelB = 2'b00;PcSource = 2'b01;ExtOp = 1'b0;AluOp = 4'b0000;
			end 
	   endcase 
	end 
	
endmodule

顶层模块如下：

module Multiple_top(
   input  clk,
   input  rstn
);


   wire PcWr;
	//wire IoD;
	wire PcWrCond;
   wire MemWr;
   wire IRWr;
   wire RegDst;
   wire RegWr;
   wire ALUSelA;
   wire [1:0] ALUSelB;
   wire BrWr;
   wire [1:0] PcSource;
   wire MDRWr;
   wire MemtoReg;
   wire  ExtOp;
   wire  [3:0] AluOp;
   wire  [31:0] instruction;

MultipleControl MultipleControl(
    .clk(clk),
    .rstn(rstn),
    .PcWr(PcWr),
	 //.IoD(IoD),
	 .PcWrCond(PcWrCond),
    .MemWr(MemWr),
    .IRWr(IRWr),
    .RegDst(RegDst),
    .RegWr(RegWr),
    .ALUSelA(ALUSelA),
    .ALUSelB(ALUSelB),
    .BrWr(BrWr),
    .PcSource(PcSource),
    .MDRWr(MDRWr),
    .MemtoReg(MemtoReg),
    .ExtOp(ExtOp),
    .AluOp(AluOp),
    .instruction(instruction)   
);

 MutipleDataPath MutipleDataPath(
		.clk(clk),
		.rstn(rstn),
		.PcWr(PcWr),
		//.IoD(IoD),
		.PcwrCond(PcWrCond),
		.MemWr(MemWr),
		.IRWr(IRWr),
		.RegDst(RegDst),
		.RegWr(RegWr),
		.ALUSelA(ALUSelA),
		.ALUSelB(ALUSelB),
		.BrWr(BrWr),
		.PcSource(PcSource),
		.MDRWr(MDRWr),
		.MemtoReg(MemtoReg),
		.ExtOp(ExtOp),
		.AluOp(AluOp),
		.instruction(instruction)
   );



endmodule 

module Shifter(
  input [31:0] alu_DB,
  input [4:0] ALUSHIFT,
  input [1:0] Shiftctr,
  output reg  [31:0] shift_result
);
  
  wire [5:0] shift_n;
  assign shift_n = 6'd32 - ALUSHIFT;
  always@(*)begin
     case(Shiftctr)
	     2'b00:  shift_result = alu_DB << ALUSHIFT;
		 2'b01:  shift_result = alu_DB >> ALUSHIFT;
		 2'b10:  shift_result = ({32{alu_DB[31]}} << shift_n) | (alu_DB >> ALUSHIFT);
		default: shift_result = alu_DB;
	 endcase
  end 

endmodule
里程。。
关注
  • 3
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
基于FPGA多通道数据采集系统verilog设计
QQ_778132974的博客
03-30 3534
本设计实现多通道数据采集系统，该系统包括多通道数据采集和数据传输，使用verilog语言设计。 本设计实现功能：采集8路16位的AD数据，并发送到串口助手。 该设计架构图如下： 顶层模块代码如下： module AD_8C_16B //输入输出端口声明，和模块定义,只有下面这里是逗号 ( //输入端口 clk_50M, rst_n, AD_data, //AD转成的16位数据 AD_BUSY, //AD的BUSY线 AD_FRETDATA, //为1时表示第一个
《计算机组成与设计》阅读笔记——流水线CPU的设计
firefly
12-12 2187
单周期CPU 单周期构造的缺陷 由于要保证所有指令在一个周期内完成，时钟周期会很长，也限制了时钟频率的提升 各种指令执行的长短时间不一（比如加法和存数据到内存）时间短的指令效率被浪费 指令类型 指令分为R-type，I-type和J-type 一般由最高6位区分 R-type指令主要执行ALU运算，具体运算由最低6位的funct段决定 I-type指令主要是和地址与常数相关的指令，如存...
基于Verilog的单周期和多周期CPU设计
Zireael2019的博客
03-12 8830
基于Verilog的单周期和多周期CPU设计，数据通路采用分散互联，控制器采用硬布线方式实现 原理方面如各条指令的流程和控制信号的内容可参考相关教材，在此不进行介绍，仅介绍核心组件的实现方法 模拟采用的是modelsim，指令集参考的是MIPS32的标准指令集，实现的十条指令格式皆取自其中
verilog实现多周期处理器之——（六）简单算数操作指令的实现
啦啦啦啦啦
12-21 5443
实现的指令说明 R-型指令 加减比较指令 add、addu、sub、sub、slt、sltu 这6条指令的格式指令码都是6’b000000，即SPECIAL类，另外第6-10bit都为0，需要依据指令中0-5bit功能码的值进一步判断是哪一种指令。 当功能码是6’b100000时，表示是add指令，加法运算 指令用法为：add rd, rs, rt 指令作用为：rd <- rs + rt，将...
Logisim平台上的单周期和多周期MIPSCPU设计（计组课设）
最新发布
qq_59961910的博客
05-21 2004
在实现时，我首先学习了指令格式，然后设计了控制器来实现不同指令的不同操作，同时利用组合逻辑和时序逻辑来完成指令的各个步骤。最后，我测试了CPU的正确性，并通过运行一些程序验证了它的性能和运行效率。例如，可以将两个比较结果信号相连，以便仅当两个比较器的结果都为 1 时，与门的输出才为 1。例如，可以将两个比较结果信号相连，以便仅当这两个比较器的结果中至少有一个为1时，或门的输出才为1。例如，可以将两个与门的输出信号相连，以便仅当这两个信号中至少有一个为 1 时，或门的输出才为 1。
【学习笔记】微体系结构-单周期、多周期、流水线
maomaochong1968的博客
04-29 6156
【学习笔记】微体系结构-单周期、多周期、流水线 前言 提示：多周期与多发射、多核不同。 单周期、多周期、流水线三者之间的演变过程如下图。 #mermaid-svg-0KLrICHRcehTwLeq {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#33.
多周期CPU设计（verilog)
Destiny的博客
02-24 1万+
多周期CPU设计报告 文章目录多周期CPU设计报告一、设计思路**1.主要参照：****2.多周期处理器**：**3.指令周期：****4.MIPS指令：**二、主要模块设计**1.总体模块构成****2. MultiCycleCPU.v****3. PCctr.v**3. ControlUnit.v**控制信号的生成**状态转换输入、输出端口声明：**3. 其他模块**四、模块间主要信号传递五、功能仿真**1. 仿真文件****2. 存储的指令****3. 测试**六、模块代码1. MultiCycle
单周期CPU,多周期CPU
热门推荐
qq_44231964的博客
05-29 2万+
单周期CPU：一个时钟周期完成一条指令，如果一个程序有多条指令，则时钟周期的时间根据执行时间最长的那条指令为主。执行一条指令就需要一个时钟周期则CPI为1。 多周期CPU：一条指令被分成了若干个阶段，假设为n个，每执行一条指令需要花费n个时钟周期，所以执行一条指令就需要n个时钟周期CPI为n。 多周期CPU比单周期CPU的优势在于：因为一个程序的不同指令所需要的执行时间是不同的，所以如果按照单周期处理的话，无论什么指令我都按照最长的那条指令去处理，可能我只要占用CPU1s，但是你给了我100s，其中99s.
Verilog 实现32位并行CRC编解码 可在一个时钟周期出结果
baozouxiaoluoli的博客
09-16 3049
Verilog 实现32位并行CRC编解码 可在一个时钟周期出结果 CRC简介 CRC(Cyclic Redundancy Check，循环冗余校验）是数据帧传输中常用的一种差错控制编码方式，针对要发送的数据帧，使用一些特定的多项式可以计算出CRC校验结果，CRC校验结果和原始数据一起传输到接收端。 接收端在接收数据的同时按照相同的多项式对接收数据进行校验运算，并将 校验结果和接收的结果进行对比，如果二二者相同则认为没有发生传输错误；如果不同，则认为是发生了传输错误。从理论上说，如果接收端计算出的CRC值与
Project6 VerilogHDL开发多周期处理器.pdf
07-03
"Project6 VerilogHDL开发多周期处理器.pdf" 指的是一项实验项目，项目的核心是使用Verilog HDL语言来设计一个多周期的处理器。Verilog HDL是一种硬件描述语言，常用于数字逻辑系统的设计，包括CPU。多周期处理器是...
基于MIPS指令集的32位CPU设计与Verilog语言实现_多周期CPU
11-22
本项目是关于基于MIPS指令集的32位CPU设计，采用Verilog硬件描述语言进行实现，且采用多周期CPU架构。 Verilog是一种标准化的硬件描述语言，用于数字电子系统的建模和仿真。在设计这个32位CPU时，Verilog允许设计者...
基于verilog的多周期cpu附设计图和流程运行图
06-15
《基于Verilog的多周期CPU设计详解》 在数字系统设计领域，Verilog是一种广泛使用的硬件描述语言（HDL），用于构建和验证复杂的数字逻辑电路，包括CPU。本项目聚焦于一个基于Verilog实现的多周期CPU，它通过多个...
MIPS32多周期CPU设计与实现（含报告）
01-28
《MIPS32多周期CPU设计与实现》 在计算机科学领域，计算机组成原理是理解计算机硬件系统工作原理的关键课程。MIPS32是一种广泛使用的精简指令集计算机（RISC）架构，它以其高效、简洁的设计理念在学术界和工业界...
verilog串口接收多个数据进行处理的实现方法
学海无涯的专栏
04-01 1577
关于使用串口接收多个数据进行处理的问题，目前网上存在的关于verilog串口通信的资料都是属于讲解对于使用串口实现单个字符的接收与发送。而往往在使用串口进行通信时，接数据端都需要通过串口来接收很多数据，然后当所有数据都接收完或者达到某种条件后开始自己的后续工作。所以在这里我把自己的一些具体实现过程以及verilog源代码分享一下，希望对大家有帮助。 (这里只讲利用串口接收数据并处理的部分，发送那部分后面再分享) 先贴上网上很多的串口接收的代码，如下; module my_uart_rx( ...
多通道数据整形器（MCDF）verilog设计（一）——通道从端模块 (slave_fifo)
Xu__Xiaoyang的博客
01-12 1185
多通道数据整形器MCDF（Multi-Channel Data Formatter），将多个通道的上行(umlink)数据经过内部的FIFO以数据包(data packet)的形式送出。
verilog中已知系统时钟频率和波特率可知传输一位数据所需周期和边沿检测电路
浮若于心
07-02 4307
设时钟频率为 clk = 50MHZ = 50_000_000 HZ; 波特率为 bound = 115200 位/秒; //每秒可以传输115200位数据. 传输一位数据所需周期数为:T_cnt = clk / bound = 50_000_000 / 115200; 其中选择clk_cnt计数至T_cnt / 2时寄存接收端口数据，是因为计数到数据中间时的采样结果最稳定。//clk_cnt是进行一个一个周期的记数. 经典的边沿检测电路，通过检测串口接收端uart_rxd的下降沿来捕获起始...
系统硬件综合设计-多周期CPU的设计与实现
秃秃然然的博客
08-03 9214
目录1 实验目的和要求 1 实验目的和要求 基于先修课程，根据系统设计思想，使用硬件描述语言设计实现一款兼容MIPS32指令集子集的处理器（CPU），完成单周期CPU设计，或多周期CPU设计，或5级流水线CPU设计（递进式、难度依次提升。必须至少完成单周期CPU的设计工作），并将设计的CPU，下载至FPGA开发板上运行。以此贯穿数字逻辑、计算机组成原理、计算机体系结构课程，实现从逻辑门至完整CPU处理器的设计。 ...
Verilog学习笔记（5）:Verilog高级程序设计
ixue
10-10 2905
verilog学习笔记；verilog知识总结；verilog考试知识点汇总；Verilog高级程序设计；数字电路系统设计；加法器树乘法；Wallace树乘法器；复数乘法器；FIR滤波器设计；片内存储器的设计；FIFO设计；键盘扫描和编码器；log函数的Verilog设计；CORDIC算法的Verilog实现；总线控制器设计；UART接口控制器；SPI接口控制器
Verilog寄存器设计
SY_XLR的博客
05-28 4803
任务描述 本关任务：编写一个异步清零带写使能端的32位寄存器。 相关知识 CPU内的隐含寄存器是一些特殊的寄存器, 对用户是不可用的,专供控制器使用。 在指令执行过程中，由硬件自动控制这些寄存器。包括程序计数器 PC 、指令寄存器 IR 、程序状态字 PSW 、存储器地址寄存器 MAR 、存储器数据寄存器 MDR 等。其中： 指令寄存器 IR :用来存放当前正在执行的指令代码。 程序计数器 PC :也称为指令指针,用来指示将要执行 的下一条指令在内存中的地址。 寄存器的功能 寄存器是计算机中实现数
p3 verilog多周期处理器开发
07-13
### 回答1： P3是一种多周期处理器，采用Verilog语言进行开发。多周期处理器是指将指令的执行过程划分为多个时钟周期，每个时钟周期执行不同的操作。在P3的开发过程中，需要实现多个阶段，包括指令取指、指令译码、执行指令、访问存储器和写回数据等。 首先，P3需要实现指令的取指阶段。在这个阶段，处理器从存储器中读取指令，并将其存储在指令寄存器中。这个过程需要进行地址的计算和内存的访问控制。 接下来是指令的译码阶段。在这个阶段，处理器将从指令寄存器中读取的指令进行译码，确定需要执行的操作，并从寄存器中读取相应的操作数。这个过程需要进行操作码的解析和寄存器的读取控制。 然后是指令的执行阶段。在这个阶段，处理器执行计算、逻辑和存储器访问等指令操作。根据指令的类型，处理器需要进行不同的操作，如加法、乘法、逻辑与、逻辑或等。执行阶段还包括一些流水线冒险的控制，如数据冒险和控制冒险。 接着是访问存储器的阶段。在这个阶段，处理器需要根据指令的类型和操作数计算出要访问的存储器地址，并从存储器中读取或写入数据。这个阶段还需要进行访存控制和数据传输的控制。 最后是写回数据的阶段。在这个阶段，处理器将执行结果写回到寄存器中，以供之后的指令使用。这个过程需要进行寄存器写入控制和数据传输的控制。 以上就是P3多周期处理器开发的基本过程。通过合理设计和优化每个阶段的控制和操作，可以提高处理器的性能和效率。同时，在开发过程中还需要考虑流水线的冒险和优化，以实现更高的指令吞吐量。 ### 回答2： P3是指基于Verilog语言进行多周期处理器开发的项目。多周期处理器是一种计算机架构，它将指令的执行划分为多个时钟周期。这种架构可以使处理器实现更高的性能，通过并行执行多个指令和提高时钟频率来提高处理器的计算速度。 在P3项目中，开发人员使用Verilog语言来描述处理器的硬件结构和功能。Verilog是一种硬件描述语言，它可以用于设计和模拟电子系统。通过使用Verilog，开发人员可以创建处理器的各个组件，如控制单元、数据通路、寄存器和运算器等。 在多周期处理器中，每个指令被划分为多个阶段或时钟周期。这些阶段包括取指(fetch)、译码(decode)、执行(execute)、访存(memory access)和写回(writeback)等。每个时钟周期，处理器将执行一个阶段的操作，并在下一个时钟周期执行下一个阶段的操作。 P3项目中的多周期处理器可以实现更复杂的指令和运算，例如整数加法、乘法和除法、浮点运算等。处理器还可以支持高级的功能，如分支预测、乱序执行和超标量执行等。 在P3项目中，开发人员需要设计和优化多周期处理器的性能和功耗。他们可能会使用性能分析工具来评估处理器的吞吐量、延迟和资源利用率等指标。同时，他们还可能会通过对电路进行面积和功耗优化来提高处理器的效率和可靠性。 总的来说，P3 Verilog多周期处理器开发项目是一个使用Verilog语言进行多周期处理器设计和优化的项目。通过这个项目，开发人员可以实现更高性能的多周期处理器，提高计算机系统的整体性能和效率。 ### 回答3： P3 Verilog多周期处理器开发是指使用Verilog语言来设计和开发一种多周期处理器。多周期处理器是一种在执行指令时将其划分为多个时钟周期的处理器结构。这样的设计允许处理器在每个周期里执行一部分的指令，从而提高整体效率和性能。 在P3 Verilog多周期处理器开发中，我们需要设计和实现一系列模块来支持多周期指令执行。这些模块包括指令执行单元、寄存器堆、控制单元等等。指令执行单元负责解码和执行指令，并将结果存储到寄存器堆中。寄存器堆用于保存需要在不同周期之间传递的数据。控制单元则负责控制整个多周期处理器的时序和操作。 在设计P3 Verilog多周期处理器时，需要考虑到如何合理划分指令执行的不同阶段。常见的划分包括取指令、解码指令、执行指令、访问存储器、写回结果等阶段。每个阶段的长度可以根据指令的复杂程度和需要的处理时间来确定。 多周期处理器相比于单周期处理器的优势是可以更好地适应不同指令的执行需要，提高处理器的效率。然而，也需要考虑到多周期处理器的设计复杂性和硬件成本。 总的来说，P3 Verilog多周期处理器开发涉及到使用Verilog语言设计和实现一种支持多周期指令执行的处理器。这需要合理划分指令执行的不同阶段，并设计相应的模块来支持指令的解码、执行和结果传输。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值