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

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

单周期处理器是指取指译码等操作在一个时钟周期内完成。本单周期处理器支持R型指令add,addu,sub,subu,slt,sltu;I型指令ori,lw,sw,beq,bne,移位指令sll,srl,sra指令;J型指令的J指令和Jr指令。单周期处理器设计包括两大部分设计,一个是控制部件的设计,另一个是数据通路的设计。
设计整体框图如下：
在这里插入图片描述

顶层模块如下

module SingleCycleCpu(clk,rst_n);

input clk;
input rst_n;

wire [31:0] instruction;
wire RegDst;
wire beq;
wire bne;
wire Jump;
wire ExtOp;
wire ALUSrc;
wire [3:0] ALUctr;
wire MemWr;
wire RegWr;
wire MemtoReg;
wire jr;


Controler Controler(
		.instruction(instruction),
		.RegDst(RegDst),
		.bne(bne),
		.beq(beq),
		.Jump(Jump),
		.ExtOp(ExtOp),
		.ALUSrc(ALUSrc),
		.ALUctr(ALUctr),
		.MemWr(MemWr),
		.RegWr(RegWr),
		.MemtoReg(MemtoReg),
		.jr(jr)
);


SingleDataPath  SingleDataPath(
		.clk(clk),
		.rst_n(rst_n),
		.RegDst(RegDst),
		.RegWr(RegWr),
		.Jump(Jump),
		.ExtOp(ExtOp),
		.ALUSrc(ALUSrc),
		.ALUctr(ALUctr),
		.MemWr(MemWr),
		.MemtoReg(MemtoReg),
		.instruction(instruction),
		.bne(bne),
		.beq(beq),
		.jr(jr)
);


endmodule

指令存储器设计如下

module RomNoDelay(
   input clk,
   input [7:0] RdAddr,
   output [31:0] RdData
);
  reg [31:0] rom [255:0];
  
  initial begin
     $readmemh("F:/work/digital_system_practise/data_path/rtl/inst_rom.data",rom);
  end 
  
  assign RdData  = rom[RdAddr];

endmodule

数据存储器设计如下

module RamNoDelay(
  input clk,
  input wen,
  input [7:0] WrAddr,
  input [31:0] WrData,
  input [7:0] RdAddr,
  output [31:0] RdData
);
 
 reg [31:0] ram [255:0];
 always@(posedge clk)begin
   if(wen)
     ram[WrAddr] <= WrData;
 end 
 
 assign RdData = ram[RdAddr];

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

alu的框图如下:
在这里插入图片描述
alu模块代码如下:

module alu(
  input [31:0] alu_DA,
  input [31:0] alu_DB,
  input [3:0] alu_CTL,
  input [4:0] alu_SHIFT,
  output 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)?1'b0:1'b1;
  /****************************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 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

取指令部件的框图
在这里插入图片描述
取指令部件模块的代码

module if_fetch(
   input rst_n,
   input clk,
   input jump,
   input beq,
   input bne,
   input zero,
   input jr,
   input [31:0] BusA,
   output [31:0] ins   
);

reg  [29:0] PC;
wire [29:0] PC_next;
wire [29:0] PC_sel;
wire [29:0] PC_Branch;
wire [29:0] PC_INC;
wire [15:0] imme;

RomNoDelay RomNoDelay(
   .clk(clk),
   .RdAddr(PC[7:0]),
   .RdData(ins)
);

always@(posedge clk or negedge rst_n)
   if(!rst_n)
     PC <= 30'd0;
   else 
     PC <= PC_next;
	 

assign imme = ins[15:0];
assign PC_INC  =  PC + 1'b1;   
assign PC_Branch  =  PC_INC + {{14{imme[15]}},imme};    
assign PC_sel  =  ((beq && zero) || (bne && !zero))?PC_Branch:PC_INC;    
assign PC_next = (jump)?{PC[29:26],ins[25:0]}
                 :(jr)? BusA[31:2]
				     :PC_sel;

endmodule

数据通路模块的代码如下

module SingleDataPath(
		clk,
		rst_n,
		RegDst,
		RegWr,
		Jump,
		ExtOp,
		ALUSrc,
		ALUctr,
		MemWr,
		MemtoReg,
		instruction,
		bne,
		beq,
		jr
);

input clk;
input rst_n;
input RegDst;
input RegWr;
input Jump;
input ExtOp;
input ALUSrc;
input [3:0]ALUctr;
input MemWr;
input MemtoReg;
input bne;
input beq;
input jr;
output [31:0]instruction;


wire zero;
wire [31:0]instruction;
wire [4:0] Rw;
wire Rwen;
wire [31:0] BusA;
wire [31:0] BusB;
wire [31:0] BusBm;
wire [31:0] BusW;
wire [31:0] ALU_DC;
wire [31:0]RdData;
wire overflow;
wire [31:0] Extimme;


wire [4:0] Rs;
wire [4:0] Rt;
wire [4:0] Rd;
wire [4:0] shift;
wire [15:0] imme;

assign Rs = instruction[25:21];
assign Rt = instruction[20:16];
assign Rd = instruction[15:11];
assign shift = instruction[10:6];
assign imme = instruction[15:0];
assign Rw = (RegDst)?Rd:Rt;
assign Rwen = (~overflow) & RegWr;
assign BusW = (MemtoReg)?RdData:ALU_DC;
assign Extimme = (ExtOp)?{{16{imme[15]}},imme}:{16'b0,imme};
assign BusBm = (ALUSrc)?Extimme:BusB;

alu alu(
	  .alu_DA(BusA),
	  .alu_DB(BusBm),
	  .alu_CTL(ALUctr),
	  .alu_SHIFT(shift),
	  .alu_ZERO(zero),
	  .alu_Overflow(overflow),
	  .alu_DC(ALU_DC)
);

dflipflop regfile( 
         .clk(clk),
		 .Ra(Rs),
		 .Rb(Rt),
		 .Rw(Rw),
		 .Wen(Rwen),
		 .BusA(BusA),
		 .BusB(BusB),
		 .BusW(BusW)
);


if_fetch if_fetch(
	   .rst_n(rst_n),
	   .clk(clk),
	   .jump(Jump),
	   .beq(beq),
	   .bne(bne),
	   .zero(zero),
	   .jr(jr),
	   .BusA(BusA),
	   .ins(instruction)  
);

RamNoDelay RamNoDelay(
     .clk(clk),
	  .wen(MemWr),
	  .WrAddr(ALU_DC),
	  .WrData(BusB),
	  .RdAddr(ALU_DC),
	  .RdData(RdData)
);

endmodule

控制部件的模块代码如下

module Controler(
    instruction,
    RegDst,
    bne,
	 beq,
    Jump,
    ExtOp,
    ALUSrc,
    ALUctr,
    MemWr,
	 RegWr,
    MemtoReg,
	 jr
);

input [31:0] instruction;
output RegDst;
output beq;
output bne;
output Jump;
output ExtOp;
output ALUSrc;
output [3:0] ALUctr;
output MemWr;
output RegWr;
output MemtoReg;
output jr;

wire [5:0] op;
wire [5:0] func;
wire R_type;
wire [3:0] aluOp1;
wire [3:0] aluOp2;


assign op = instruction[31:26];
assign func = instruction[5:0];
assign jr = ((op == 6'b000000) && (func == 6'b001000));

maincontrol maincontrol(
		.op(op),
		.RegDst(RegDst),
		.beq(beq),
		.bne(bne),
		.Jump(Jump),
		.ExtOp(ExtOp),
		.ALUSrc(ALUSrc),
		.aluOp(aluOp1),
		.MemWr(MemWr),
		.RegWr(RegWr),
		.MemtoReg(MemtoReg),
		.R_type(R_type)
);

aluControl aluControl(
	   .func(func),
	   .aluOp(aluOp2)
);

assign ALUctr = (R_type)?aluOp2:aluOp1;

				
endmodule 

module maincontrol(
    op,
	RegDst,
	beq,
	bne,
	Jump,
	ExtOp,
	ALUSrc,
	aluOp,
	MemWr,
	MemtoReg,
	RegWr,
	R_type
);

input [5:0] op;
output RegDst;
output RegWr;
output Jump;
output ExtOp;
output ALUSrc;
output [3:0] aluOp;
output MemWr;
output MemtoReg;
output R_type;
output beq;
output bne;

wire ls;
wire lw = (op == 6'b100011);
wire sw = (op == 6'b101011);
wire beq1 = (op == 6'b000100);
wire bne1 = (op == 6'b000101);
wire j = (op == 6'b000010);
wire ori = (op == 6'b001101);

assign R_type = (op == 6'b000000);
assign RegDst = R_type;
assign RegWr = R_type | lw | ori;
assign beq = beq1; 
assign bne = bne1;
assign Jump = j;
assign ExtOp = lw | sw;
assign ALUSrc = lw | sw | ori;
assign MemWr  = sw;
assign MemtoReg = lw;
assign ls = lw | sw;

assign aluOp =  ({4{ls}}&4'b0001) | ({4{beq}}& 4'b0011) | ({4{bne}}& 4'b0011)|({4{ori}}& 4'b0101);
				
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

1、 总体仿真验证
1.1 验证方案
然后把之前编写的makefile，BinMem.exe,ram.ld放到源代码所在的目录，输入命令make all，得到与汇编代码相匹配的16进制格式的指令，仿真时将汇编代码的结果与仿真结果比较。
编写的inst_rom.S如下:

.org 0x0
   .set noat
   .set noreorder
   .set nomacro
   .global _start
_start:


   ori   $1,$0,0x8000           # $1 = 0x00008000
   sll   $1,$1,16               # $1 = 0x80000000
   ori   $1,$1,0x0010           # $1 = 0x80000010

   ori   $2,$0,0x8000           # $2 = 0x00008000
   sll   $2,$2,16               # $2 = 0x80000000
   ori   $2,$2,0x0001           # $2 = 0x80000001

   ori   $3,$0,0x0000           # $3 = 0x00000000
   addu  $3,$2,$1               # $3 = 0x00000011
   ori   $3,$0,0x0000           # $3 = 0x00000000
   

   sub   $3,$1,$3              # $3 = 0x80000010         
   subu  $3,$3,$2              
   

   #########     slt\sltu    ##########

   ori   $1,$0,0xffff           # $1 = 0xffff
   sll  $1,$1,16               # $1 = 0xffff0000
   slt  $2,$1,$0               # $2 = 1
   sltu $2,$2,$0               # $2 = 0
  
   #########     lw\sw    ##########
   ori  $3,$0,0x4455
   sll  $3,$3,0x10
   ori  $3,$3,0x6677     
   sw   $3,0x8($0)       # [0x8] = 0x44, [0x9]= 0x55, [0xa]= 0x66, [0xb] = 0x77
   lw   $1,0x8($0)       # $1 = 0x44556677
   
   #########     sll\srl    ##########
   sll  $1,$1,4          # $1 = 0x45566770
   srl  $1,$1,4          # $1 = 0x04556677
   ori  $1,$0,0x8000    # $1 = 0x00008000
   sll   $1,$1,16        # $1 = 0x80000000
   sra   $1,$1,4         # $1 = 0xf8000000
   
   bne   $1,$0,N1   
   nop
   nop
   
   N1:   beq $1,$1,s3
   
   s3:   ori   $1,$0,0x80           #  $1 = 0x00000080
         jr    $1                     #  $1 =0x00000080   跳转到           0x00000080处
   
   .org 0x80
   j  0x90
   
   .org 0x90
   ori   $2,$0,56                 # $2 = 56 
   ori   $1,$0,4                 # $1 = 4
   ori   $3,$0,0                 # $3 = 0
   add   $3,$1,$2                # $3 = 60

生成的初始化ROM中的16进制指令如下
34018000
00010c00
34210010
34028000
00021400
34420001
34030000
00411821
34030000
00231822
00621823
3401ffff
00010c00
0020102a
0040102b
34034455
00031c00
34636677
ac030008
8c010008
00010900
00010902
34018000
00010c00
00010903
14200002
00000000
00000000
10210000
34010080
00200008
00000000
08000024
00000000
00000000
00000000
34020038
34010004
34030000
00221820

1.2 仿真结果(所有指令格式与ROM中一致，为16进制)
34210010 ori $1,$1,0x0010 # $1 = 0x80000010
观察BusW为0x80000010
在这里插入图片描述
00411821 addu $3,$2,$1 # $3 = 0x00000011
观察BusW为0x00000011
在这里插入图片描述
00231822 sub $3,$1,$3 # $3 = 0x80000010
观察BusW为0x80000010
在这里插入图片描述
0020102a slt $2,$1,$0 # $2 = 0xffffffff
观察BusW为0xffffffff
在这里插入图片描述
ac030008为sw指令的16进制编码，8c010008为lw指令的16进制编码
sw $3,0x8($0) # [0x8] = 0x44, [0x9]= 0x55, [0xa]= 0x66, [0xb] = 0x77
lw $1,0x8($0) # $1 = 0x44556677
观察BusW的为0x44556677
在这里插入图片描述
00010900 sll $1,$1,4 # $1 = 0x45566770
观察BusW的为0x45566770
在这里插入图片描述
00010902 srl $1,$1,4 # $1 = 0x04556677
观察BusW的为0x04556677
在这里插入图片描述
00010903 sra $1,$1,4 # $1 = 0xf8000000
观察BusW的为0xf8000000
在这里插入图片描述
bne $1,$0,N1
nop
nop

N1: beq $1,$1,s3

s3: ori $1,$0,0x80 # $1 = 0x00000080
如果执行到最后一步,说明beq和bne指令执行正确

观察BusW的值为0x00000080,且取出的指令为34010080,就是ori指令的16进制编码
在这里插入图片描述

jr $1 # $1 =0x00000080 跳转到 0x00000080处
.org 0x80
j 0x90

.org 0x90
ori $2,$0,56 # $2 = 56
ori $1,$0,4 # $1 = 4
ori $3,$0,0 # $3 = 0
add $3,$1,$2 # $3 = 60
如果最后四条指令执行了,j和jr指令仿真正确

Add指令16进制编码为00221820,为最后一条指令，最后结果得60
观察BusW的值依次为56,4,0,60
在这里插入图片描述
到此完整的单周期处理器设计加仿真就完成了。
附上控制器的仿真代码

`timescale 1ns/1ns

module Controler_tb;

reg[31:0] instruction;
wire RegDst;
wire beq;
wire bne;
wire Jump;
wire ExtOp;
wire ALUSrc;
wire [3:0] ALUctr;
wire MemWr;
wire MemtoReg;
wire jr;
wire RegWr;


Controler Controler(
		 .instruction(instruction),
		 .RegDst(RegDst),
		 .bne(bne),
		 .beq(beq),
		 .Jump(Jump),
		 .ExtOp(ExtOp),
		 .ALUSrc(ALUSrc),
		 .ALUctr(ALUctr),
		 .MemWr(MemWr),
		 .MemtoReg(MemtoReg),
		 .RegWr(RegWr),
		 .jr(jr)
);

initial begin
    /**********add*******/
    instruction = 32'b000000_00000_00000_00000_00000_100000;
	 #5;
	 
	 /**********addu*******/
	 instruction = 32'b000000_00000_00000_00000_00000_100001;
	 #5;
	 
	 /**********sub*******/
	 instruction = 32'b000000_00000_00000_00000_00000_100010;
	 #5;
	 
	 /**********subu*******/
	 instruction = 32'b000000_00000_00000_00000_00000_100011;
	 #5;
	 
	 /**********slt*******/
	 instruction = 32'b000000_00000_00000_00000_00000_101010;
	 #5;
	 
	 /**********sltu*******/
	 instruction = 32'b000000_00000_00000_00000_00000_101011;
	 #5;
	 
	 /**********and*******/
	 instruction = 32'b000000_00000_00000_00000_00000_100100;
	 #5;
	 
	 /**********or*******/
	 instruction = 32'b000000_00000_00000_00000_00000_100101;
	 #5;
	 
	 /**********xor*******/
	 instruction = 32'b000000_00000_00000_00000_00000_100110;
	 #5;
	 
	 /**********nor*******/
	 instruction = 32'b000000_00000_00000_00000_00000_100111;
	 #5;
	 
	 /**********sll*******/
	 instruction = 32'b000000_00000_00000_00000_00000_000000;
	 #5;
	 
	 /**********srl*******/
	 instruction = 32'b000000_00000_00000_00000_00000_000010;
	 #5;
	 
	 /**********sra*******/
	 instruction = 32'b000000_00000_00000_00000_00000_000011;
	 #5;
	 
	 /**********beq*******/
	 instruction = 32'b000100_00000_00000_00000_00000_000000;
	 #5;
	 
	 /**********bne*******/
	 instruction = 32'b000101_00000_00000_00000_00000_000000;
	 #5;
	 
	 /**********jr*******/
	 instruction = 32'b000000_00000_00000_00000_00000_001000;
	 #5;
	 
	 /**********j*******/
	 instruction = 32'b000010_00000_00000_00000_00000_000000;
	 #5;
	 
	 #10;
	 $stop;

end

endmodule
里程。。
关注
单周期CPU verilog设计代码和仿真代码
12-28
单周期CPU的设计，使用结构级语句与描述级语句构建寄存器堆、ALU、CONUNIT等模块，支持12条指令：add、sub、j、bne、bnq等
一个简单LEGv8处理器的Verilog实现【四】【单周期实现基础知识及模块设计讲解】
凳子花❀的博客
06-05 2239
文章目录博客结构安排本系列其他博客源码下载参考资料参考资料下载 好的，本节就先讲到这里，如果你有收获且乐意的话，麻烦点个赞哦，收藏也可以哇(￣▽￣)~* 博客结构安排 本系列博客共分为5篇： 第一篇对一些处理器基础知识进行简单讲解，并讲清楚实验要求。 第二篇从指令、寄存器、汇编器的角度对设计处理器所需要的基础知识进行较为详细的讲解，并对实验所需汇编程序进行了分析。 本系列其他博客 一个简单LEGv8处理器的Verilog实现【一】【实验简介】 一个简单LEGv8处理器的Verilog实现【二】【基
基于Logisim和Mars仿真器构建32位单周期CPU处理器设计
毕业作品网站
02-11 3454
ALU的主要功能是完成算术运算和逻辑运算，本次设计的ALU可执行的算术运算包括加法和减法，逻辑运算包括或运算。GPR的主要功能是完成对32个32位寄存器的读写功能，有两个读端口和一个写端口，根据RA和RB的值分别选择要读取的寄存器，根据RW的值选择要写入的寄存器。如果当前指令是beq指令，并且zero为1，则PCPC+4+(sign_ext(ins[15:0])
计算机原理与结构 实验3 《单周期微处理器设计》
Atlas
08-06 1448
计算机原理与结构 实验3 《单周期微处理器设计》 一、实验目的 1、掌握：如何采用System Verilog设计时序逻辑电路； 2、掌握：利用Quartus II / Modelsim 设计仿真CPU的基本原理和方法； 3、掌握：指令系统的设计与实现方法。 二、实验内容 用System Verilog设计一个单周期的ARM微处理器，其体系结构描述如下： // 16 32-bit registers // Data-processing instructions // ADD, SUB, AND, OR
《计算机组成原理》单周期CPU处理器的Verilog设计
qq_44040327的博客
05-04 8276
《计算机组成原理》单周期CPU处理器的设计一、实验原理1. 单周期CPU2. 单周期CPU指令模块3. MIPS指令格式4. 指令处理流程5. 单周期CPU数据通路二、单周期CPU的设计1.pcadd42. PC3.INSTMEM4. DATAMEM5. DATAMEM三、设计运行结果总结 一、实验原理 1. 单周期CPU 单周期CPU可以看成由数据通路和和控制部件两大部分组成。数据通路是指在指令执行过程中，数据所经过的路径和路径上所涉及的功能部件。而控制部件则根据每条指令的不同功能，生成对不同数据通路的
计算机组成原理期末大作业基于VerilogHDL完成单周期处理器开发源代码+课程设计报告
05-14
计算机组成原理期末大作业基于VerilogHDL完成单周期处理器开发源代码+课程设计报告 1.处理器应实现MIPS-Lite1指令集。 MIPS-Lite1＝MIPS-Lite，addi，addiu， slt，jal，jr。 MIPS-Lite指令集：addu，subu，ori，lw...
Project6 VerilogHDL开发多周期处理器.pdf
07-03
- "多周期CPU" 是项目的核心，多周期处理器设计通常比单周期处理器更复杂，但能提供更好的性能和控制。 - "mips" 是MIPS（Microprocessor without Interlocked Pipeline Stages）架构，一种流行的精简指令集计算机...
机组大作业：基于RISC-V架构的45条指令单周期CPU设计
01-20
这个项目涵盖了计算机组成原理的核心概念，包括硬件描述语言（如Verilog）的应用、处理器设计、以及RISC-V指令集的实现。 首先，我们需要理解RISC-V架构的基本特性。RISC-V的设计哲学是减少指令数量，提高每条指令...
北京工业大学计算机组成原理课程设计p1 VerilogHDL完成单周期处理器开发实验报告
07-09
【计算机组成原理】\n\n本课程设计的目标是基于Verilog HDL语言，构建一个能够执行MIPS-Lite1指令集的单周期处理器。MIPS-Lite1指令集包括了如addi、addiu、slt、jal、jr等基本指令，并且在处理addi指令时需要考虑...
基于FPGA的单周期处理器设计MIPS指令集
07-24
基于FPGA的单周期处理器设计是一种高效且灵活的实现方式，它旨在将处理器的各个操作在一个时钟周期内完成，从而提高系统性能。本项目聚焦于实现MIPS（Microprocessor without Interlocked Pipeline Stages）指令集，...
Verilog 单周期CPU代码 及汇编代码 9条指令
07-14
Verilog 单周期CPU代码 及汇编代码 完美运行各种代码
Verilog 语言设计单周期MIPS CPU（42条指令）
05-23
实验内容（ISA2新增3条指令） • 用硬件描述语言（Verilog）设计MIPS CPU，支持如下指令集 • ISA1 = {ADD/ADDU/SUB/SUBU/SLL/SRL/SRA/SLLV/SRLV/SRAV/AND/OR/XOR/NOR/ SLT/SLTU/ADDI/ADDIU/ANDI/ORI/XORI/LUI/SLTI/SLTIU/LB/LBU/LH/LH U/LW/SB/SH/SW/BEQ/BNE/BGEZ/BGTZ/BLEZ/BLTZ/J/JAL/JR/JALR} 42条 • ISA2 = {add, sub, addu, subu, addi, ori, lui, and, andi, or, nor，slt, sltu, sll, srl, sllv, srlv, lw, sw, beq, bne, j, jal, jr} 24条 • 用仿真软件Modelsim对有数据冒险和控制冒险的汇编程序进行仿 文件包含源代码以及实验报告。
Verilog的135个经典设计实例 (1).pdf
03-11
本文件给出了常用的Verilog经典设计实例，如最为典型的加法器，各种类型触发器，各种模数的不同计数器等等，此外还含有一些较为复杂的电路设计，对于初学Verilog的人而言具有很大帮助。
【C/C++ & 汇编语言 & Verilog】越界截断——数据越界问题的多角度分析
X
02-23 2473
计算机是有容量限制的，因此，存储数据的大小是受限的，如果在某个过程中，数据大小超过了限度，多出来的部分，就会被计算机“截断”，从而造成数据丢失，在计算机体系结构的各个层级、各层级的各个阶段，都可能发生这种事情，设计者要尽可能避免这种问题。 但同时，辩证的角度来说，越界截断现象，也可以发挥积极作用，人类发明了补码，利用越界截断，使计算机能够将减法运算转换为加法运算，减少了很多麻烦。
MIPS指令集单周期CPU兼Verilog学习
wuyzh39的博客
12-16 4456
基于MIPS架构的单周期CPU，利用verilog硬件描述语言，烧入basys3板上。
基于FPGA实现“俄罗斯方块”游戏设计（含代码示例）
最新发布
dpwkj的博客
06-24 249
今天给各位大侠带来基于FPGA的“俄罗斯方块”设计，设计思路以及代码参考文档。本篇主要在FPGA上实现了一个经典小游戏“俄罗斯方块”。本项目基本解决方案是，使用Xilinx Zynq系列开发板ZedBoard作为平台，实现主控模块，通过VGA接口来控制屏幕进行显示。
Verilog专题（二十九）Serial receiver and datapath（串口协议）
Andy_ICer的博客
08-01 573
Verilog专题（二十九）Serial receiver and datapath（串口协议）
计算机组成原理-Verilog课程设计制作8位CPU简析
qq_51135645的博客
12-10 7321
前言 课设时间已经过去一周了，有人还是不甚了解自己在写什么（QwQ），我说一些我对需要我们做的部分的见解吧。整个文章分为模块篇、信号篇、top连线篇和查错篇。（很多人不会以为我只会传C++的实验吧） 一、模块篇 Verilog语言和常规语言有很大的不同，常规语言我们做的是一个顺序执行的过程，从头往后写就完事了，Verilog，与其说是语言，不如说是“电路连线模拟器”。 连线之前我们应该干什么？应该了解每个模块的作用，先写模块。很多人上来就跟风写信号，最...
MIPS单周期CPU设计
weixin_58792656的博客
05-16 1109
用硬件描述语言（Verilog）设计单周期CPU，支持如下指令集：用仿真软件Modelsim对汇编程序进行仿真测试.1. 熟悉硬件描述语言（Verilog）和仿真软件Modelsim；2. 用硬件描述语言（Verilog）设计程序计数器模块（PcUnit）；3. 用硬件描述语言（Verilog）设计指令存储器模块（IM）；4.用硬件描述语言（Verilog）设计寄存器模块（GPR）；5.用硬件描述语言（Verilog）设计数据扩展模块（Extender）；
北工大verilog单周期处理器
07-20
### 回答1： 北工大Verilog单周期处理器是...总之，北工大verilog单周期处理器是一种基于verilog语言设计的简单、易理解和易实现的单周期处理器，具有多种指令和功能，并可以通过优化和扩展满足不同应用场景的需求。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值