verilog实现32位5级流水线简易cpu(可执行5条指令，带数据冲突、分支跳转）

最新推荐文章于 2024-04-28 22:15:38 发布
最新推荐文章于 2024-04-28 22:15:38 发布
阅读量3.3k 收藏 55
点赞数 6
文章标签： verilog cpu 经验分享
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhidalishen/article/details/110243913
版权

这里写自定义目录标题


正在学习计算机组成原理，以下为计组大作业，借鉴了很多其他人的代码加入了自己的更改。仅供学习使用。这里实现的5条操作指令为：
ADD R1 R2 R3 :R3=R1+R2;加和赋值操作
XOR R1 R2 R3 :R3=R1^R2;异或赋值操作
LOAD R1 R2 VAl1:R2=MEM[R1+VAL1]从memory载入数据
STORE R1 R2 VAL2: MEM[R1+VAL2]=R1;向memory写入数据
beq R1 R2 VAL3 : if(R1==R2) PC=PC+1+VAL3;条件跳转

在这里插入图片描述
这个是简易CPU的5级流水线流程图。关于各个部分具体的内容介绍我就不赘述了，可以去网上查找资料。关于流水线操作的数据冲突以及操作冲突的内容也不做过多的介绍。主要是放代码。
在这里插入图片描述
上图为32位操作指令的结构，【31-25】位没用上全部置零。【24-22】为指令的标志位，用来区分指令。【21-19】，【18-16】为两个寄存器的地址位，用来指示被操作数的地址，在指令被读取之后会到对应的寄存器中提取数据，然后进行操作。第一个指令类型使用于ADD和XOR，LOAD、STORE、beq适用于第二个指令类型。

简易CPU的结构：
1 PCPU 主要模块：用从指令内存得到的指令进行运算处理，并从数据内存中写入或读取数据。这是最核心的部分，其他模块都很好设计。

2 Instruction_Mem 指令模块： 为PCPU模块提供指令，使得PCPU中通过指令寄存器中的值，找到指令的内存地址，从而读取指令。

3 Data_Mem 数据模块： PCPU从中读取数据或写入数据
在这里插入图片描述
上图借鉴博客：https://blog.csdn.net/august717/article/details/46120163，感觉这个写的比我好，大家可以去看看。
上代码：
头文件 headfile.v


`ifndef HEADFILE_H_

`define idle 1'b0
`define exec 1'b1
`define LOAD 3'b010
`define STORE 3'b011
`define ADD 3'b000
`define XOR 3'b001
`define beq 3'b100

`define gr0 3'b000
`define gr1 3'b001
`define gr2 3'b010
`define gr3 3'b011
`define gr4 3'b100
`define gr5 3'b101
`define gr6 3'b110
`define gr7 3'b111 
`endif

顶层cpu.v

module cpu( input wire clk, enable, reset, start); 

wire [31:0] d_datain; //data from memory 
wire [31:0] i_datain; //instruction
wire [7:0] d_addr;    //address for data memory
wire [31:0] d_dataout;//output data to data memory
wire d_we;            //write datamemory write enable 
wire [7:0] i_addr;    //pc
PCPU pcpu(
    .clock(clk),
    .enable(enable),
    .reset(reset),
    .start(start),
    .d_datain(d_datain),
    .i_datain(i_datain),
    .d_addr(d_addr),
    .d_dataout(d_dataout),
    .d_we(d_we),
    .i_addr(i_addr)
);
I_mem i_mem(
    .addra(i_addr),
    .douta(i_datain)
);
D_mem d_mem(
    .wea(d_we),
    .addra(d_addr),
    .dina(d_dataout),
    .douta(d_datain)
);
endmodule

底层：PCPU.v

`include "headfile.v"

module PCPU(input wire reset, enable, clock, start,
    input wire [31:0] d_datain,  //data from memory 
    i_datain,                    //instruction
    output wire [7:0] d_addr,    //address for data memory 
    output wire [7:0] i_addr,    //pc
    output wire [31:0] d_dataout,//output data to data memory 
    output wire d_we             //write enable 
    );
reg state,next_state;  //to control the CPU  
reg [7:0] pc;
reg [31:0] id_ir,ex_ir,mem_ir,wb_ir;
reg [31:0] reg_A, reg_B, reg_C, reg_C1, smdr, smdr1, ALUo; 
reg dw, zf, nf, cf, cin,flag;
reg [31:0] gr[0:7];
assign d_dataout = smdr1;
assign d_we = dw;
assign d_addr = reg_C[7:0];//***** 
assign i_addr = pc;
//************* CPU control *************//
always @(posedge clock or negedge reset)
    begin
        if (!reset)
            state <= `idle;
        else
            state <= next_state;
    end
always @(*)
    begin
        case (state)
            `idle : 
                if ((enable == 1'b1) && (start == 1'b1)) // on
                    next_state <= `exec;
                else    
                    next_state <= `idle;
            `exec :
                if (enable == 1'b0)//pause
                    next_state <= `idle;
                else
                    next_state <= `exec;
        endcase
    end

//************* IF *************// 
always @(posedge clock or negedge reset)
    begin
        if (!reset)
            begin
                id_ir <= 32'b0000_0000_0000_0000_0000_0000_0000_0000;
                pc <= 8'b0000_0000;
            end

        else if (state ==`exec)
            begin   
  
            //Load hazard  Stall    
               if((id_ir[24:22] == `LOAD)&&(i_datain[24:22]!=`LOAD)) 
                 begin
   
                      //r2
                    if((id_ir[18:16]==i_datain[18:16])&&((i_datain[24:22]==`STORE)||(i_datain[24:22]==`ADD)||(i_datain[24:22]==`XOR)))
                       begin
                         pc <= pc;
                         id_ir <= 16'bx;
                       end
                      //r3
                   else if((id_ir[18:16]==i_datain[21:19])&&((i_datain[24:22]==`STORE)||(i_datain[24:22]==`ADD)||(i_datain[24:22]==`XOR)))

 
 
                       begin
                         pc <= pc;
                         id_ir <= 16'bx;
                       end
                      else
                         begin
                            pc <= pc + 1'b1;
                         id_ir <= i_datain;
                          end
                   end
               else if(id_ir[24:22] == `beq || ex_ir[24:22] == `beq)
                    begin
                         pc <= pc;
                         id_ir <= 16'bx;
                       end
               else if((mem_ir[24:22] == `beq)&& (flag == 1'b1)) 
                   begin
                    pc <= pc+mem_ir[7:0];
                    id_ir <= 16'bx;
                   end
               else
                   begin
                       pc <= pc + 1'b1;
                       id_ir <= i_datain;
                    end
            end
         else if(state==`idle)
                begin
                   id_ir <= id_ir;
                    pc <= pc;
                end         
    end
//************* ID *************//
always @(posedge clock or negedge reset)
    begin
        if (!reset)
            begin
                ex_ir <= 32'b0000_0000_0000_0000_0000_0000_0000_0000;
                reg_A <= 32'b0000_0000_0000_0000_0000_0000_0000_0000;
                reg_B <= 32'b0000_0000_0000_0000_0000_0000_0000_0000; 
                smdr <= 32'b0000_0000_0000_0000_0000_0000_0000_0000;
            end
        //flush
       // else if(state == `exec && (ex_ir[15:11]==`BZ && zf==1'b1))
       //       ex_ir <= 16'bx;

      else if (state == `exec)
            begin
                ex_ir <= id_ir;
               //regA
              
                //r1=r2#r3 or r1=r2#val 
                 if(id_ir[24:22] == `LOAD || id_ir[24:22] == `STORE || id_ir[24:22] == `ADD || id_ir[24:22] == `XOR) 
                    begin
                       //r2
                       if( (ex_ir[24:22] == `ADD || ex_ir[24:22] == `XOR||ex_ir[24:22] == `beq )&& ex_ir[2:0] == id_ir[21:19])
                            reg_A <= ALUo;
                       else if( (mem_ir[24:22] == `ADD || mem_ir[24:22] == `XOR ||mem_ir[24:22] == `beq )&& mem_ir[2:0] == id_ir[21:19])
                            reg_A <= reg_C;
                       else if( mem_ir[24:22] == `LOAD && mem_ir[18:16] == id_ir[21:19])
                            reg_A <= d_datain;
                       else if( (wb_ir[24:22] == `ADD || wb_ir[24:22] == `XOR ||wb_ir[24:22] == `beq)&& wb_ir[2:0] == id_ir[21:19])
                            reg_A <= reg_C1;
                       else if( wb_ir[24:22] == `LOAD && wb_ir[18:16] == id_ir[21:19]) 
                            reg_A <= reg_C1; 
                        else
                            reg_A <= gr[id_ir[21:19]];//gr2
                     end    
                 
               
                else
                    reg_A <= gr[id_ir[21:19]];//gr2
                //regB
                if (id_ir[24:22] == `LOAD || id_ir[24:22] == `STORE )
                    reg_B <= {28'b0000_0000_0000, id_ir[3:0]};//val3

                //r1=r2#r3
                else if(id_ir[24:22] == `ADD || id_ir[24:22] == `XOR||id_ir[24:22] == `beq)
                   begin
                       if( (ex_ir[24:22] == `ADD  || ex_ir[24:22] == `XOR ||ex_ir[24:22] == `beq )&& ex_ir[2:0] == id_ir[18:16])
                            reg_B <= ALUo;
                        else if( (mem_ir[24:22] == `ADD || mem_ir[24:22] == `XOR ||mem_ir[24:22] == `beq )&& mem_ir[2:0] == id_ir[18:16])
                             reg_B <= reg_C;
                        else if( mem_ir[24:22] == `LOAD && mem_ir[18:16] == id_ir[18:16])
                             reg_B <= d_datain;
                        else if( (wb_ir[24:22] == `ADD || wb_ir[24:22] == `XOR ||wb_ir[24:22] == `beq)&& wb_ir[2:0] == id_ir[18:16])
                             reg_B <= reg_C1;
                        else if( wb_ir[24:22] == `LOAD && wb_ir[18:16] == id_ir[18:16])
                             reg_B <= reg_C1;
                        else
                            reg_B <= gr[id_ir[18:16]];//gr2
                     end

                else
                    reg_B <= gr[id_ir[18:16]];//gr3
               //STORE  
               if (id_ir[24:22] == `STORE)
                   begin
                      //r1???
                      if(id_ir[18:16] == ex_ir[2:0] && (ex_ir[24:22] == `ADD || ex_ir[24:22] == `XOR ))
                           smdr <= ALUo;
                      else if(id_ir[18:16] == mem_ir[2:0] && (mem_ir[24:22] == `ADD || mem_ir[24:22] == `XOR))    
                           smdr <= reg_C;                  
                     else if(id_ir[18:16] == mem_ir[18:16] && mem_ir[24:22] == `LOAD)
                           smdr <= d_datain;
                      else if(id_ir[18:16] == wb_ir[2:0] && (wb_ir[24:22] == `ADD || wb_ir[24:22] == `XOR ))
                           smdr <= reg_C1;
                      else if(id_ir[18:16] == wb_ir[18:16] && wb_ir[24:22] == `LOAD  )
                           smdr <= reg_C1;
                      else
                          smdr <= gr[id_ir[18:16]]; 
                    end
                else
                    smdr <= gr[id_ir[18:16]];


            end
   end
//************* ALU *************//
reg signed [31:0] reg_A1;
always @(*)
begin
  reg_A1 <= reg_A;
end

always @(*)
    begin
      
      if(ex_ir[24:22] == `ADD ) 
         {cf, ALUo} <= reg_A + reg_B;

      else if(ex_ir[24:22] == `XOR)
         {cf, ALUo} <= reg_A ^ reg_B;

      
      else if(ex_ir[24:22] == `LOAD || ex_ir[24:22] == `STORE)
          {cf, ALUo} <= reg_A + reg_B;
      else if(ex_ir[24:22] == `beq)
          begin
            if(reg_A ^ reg_B ==0)
              flag = 1'b1;
            else
              flag =1'b0;
          end
      else 
         {cf, ALUo} <= 33'b0;
    end     
//************* EX *************//  
always @(posedge clock or negedge reset)
    begin
        if (!reset)
            begin
                mem_ir <= 32'b0000_0000_0000_0000_0000_0000_0000_0000;
                reg_C <= 32'b0000_0000_0000_0000_0000_0000_0000_0000;
                smdr1 <= 32'b0000_0000_0000_0000_0000_0000_0000_0000;
                zf <= 1'b0;
                nf <= 1'b0;
                cin <= 1'b0;
                dw <= 1'b0;
            end 
       else if (state == `exec)
            begin
                mem_ir <= ex_ir;
                reg_C <= ALUo;

                if (ex_ir[24:22] == `ADD)
                    begin
                        if (ALUo == 32'b0000_0000_0000_0000_0000_0000_0000_0000)
                            zf <= 1'b1;//if zero
                        else
                            zf <= 1'b0;
                        if (ALUo[31] == 1'b1)//if negative 
                            nf <= 1'b1;
                        else
                            nf <= 1'b0;
                    end
                else
                  begin
                     zf <= zf;
                      nf <= nf;
                  end
                //carry 
                if (ex_ir[24:22] == `ADD)                  
                      cin <= cf;
                else
                      cin <= cin; 
                //STORE   
                if (ex_ir[24:22] == `STORE)
                    begin
                        dw <= 1'b1;//data wire enable
                        smdr1 <= smdr;
                    end
                else
                   begin
                       dw <= 1'b0;
                        smdr1 <= 32'b0;
                    end

            end
   end    
//************* MEM *************//
always @(posedge clock or negedge reset)
    begin
        if (!reset)
            begin
                wb_ir <= 32'b0000_0000_0000_0000_0000_0000_0000_0000;
                reg_C1 <= 32'b0000_0000_0000_0000_0000_0000_0000_0000;
            end 
        else if (state == `exec)
            begin
                wb_ir <= mem_ir;
                if (mem_ir[24:22] == `LOAD)
                        reg_C1 <= d_datain;
                else
                        reg_C1 <= reg_C;
            end
   end      
//************* WB *************//
always @(posedge clock or negedge reset)
    begin
        if (!reset)
            begin
                gr[7] <= 32'h00000001;
                gr[6] <= 32'h00000001;
                gr[5] <= 32'h00000001;
                gr[4] <= 32'h00000002;
                gr[3] <= 32'h00000001;
                gr[2] <= 32'h00000001;
                gr[1] <= 32'h00000001;
                gr[0] <= 32'h00000001;
            end 
        else if (state == `exec)
            begin
                if (wb_ir[24:22] == `LOAD)  
                    gr[wb_ir[18:16]] <= reg_C1;//write back to gr1
                else if((wb_ir[24:22] == `ADD) ||(wb_ir[24:22] == `XOR))
                    gr[wb_ir[2:0]] <= reg_C1;//write back to gr1
                else
                   gr[wb_ir[18:16]] <= gr[wb_ir[18:16]];
            end
   end      

endmodule

底层2 instraction-mem.v

`include "headfile.v"
module I_mem(input wire [7:0] addra, output reg [31:0] douta);
reg [31:0] i_mem[20:0];
always @(*)
   begin
        douta <= i_mem[addra];
    end

initial begin

    //gcm
    i_mem[0] <= {7'b0000000, `ADD, `gr6, `gr1, 13'b0, `gr2}; //gr2=gr6+gr1
    i_mem[1] <= {7'b0000000, `XOR, `gr4, `gr5, 13'b0, `gr6}; //gr6=gr4^gr5
    i_mem[2] <= {7'b0000000,`LOAD, `gr3, `gr4, 16'h0001}; //gr4 = mem[gr3+1]
    i_mem[3] <= {7'b0000000, `ADD, `gr2, `gr5, 13'b0, `gr5}; //gr5=gr2+gr5
    i_mem[4] <= {7'b0000000,`STORE, `gr3, `gr7, 16'h0005}; //mem[gr3+5]=gr7
    
   //???? test
    i_mem[6] <= {7'b0000000, `ADD, `gr6, `gr1, 13'b0, `gr4}; //gr4=gr6+gr1
    i_mem[7] <= {7'b0000000, `ADD, `gr4, `gr5, 13'b0, `gr1}; //gr1=gr4+gr5
   
    //???? teat
    i_mem[9] <= {7'b0000000,`beq, `gr5, `gr6, 12'h000,4'b0010};//if gr6==gr5,pc=0001+1;
    i_mem[10] <= {7'b0000000, `ADD, `gr6, `gr1, 13'b0, `gr2}; //gr2=gr6+gr1
    i_mem[11] <= {7'b0000000, `ADD, `gr3, `gr5, 13'b0, `gr5}; //gr5=gr3+gr5
    i_mem[12] <= {7'b0000000, `ADD, `gr3, `gr5, 13'b0, `gr5}; //gr5=gr3+gr5
    
end

endmodule

底层3 data-mem.v

module D_mem(input wire wea, input wire [7:0] addra, input wire [31:0] dina, output wire [31:0] douta
    );
reg [31:0] d_mem[255:0];

assign  douta = d_mem[addra];
always @(*)
   begin
        if(wea == 1'b1)
             d_mem[addra] <= dina;
   end
initial begin
 //data
  d_mem[0] <= 32'h00000000;
  d_mem[1] <= 32'h00000001;  //1
  d_mem[2] <= 32'h00000005;   //5
  d_mem[3] <= 32'h00000008;//8
end
endmodule

测试代码：test.v

module test;
    // Inputs
    reg clk;
    reg enable;
    reg reset;
    reg start;

    // Instantiate the Unit Under Test (UUT)
    cpu uut (
        .clk(clk), 
        .enable(enable), 
        .reset(reset), 
        .start(start)
    );
   always #5 clk = ~clk;
    initial begin
        // Initialize Inputs
        clk = 0;
        enable = 0;
        reset = 0;
        start = 0;

      $monitor("%h:%b:%h:%h:%h:%h:%h:%h:%b:%h:%h:%h:%h:%h:%h:%h:%h:%b:%b:%b", 
         uut.pcpu.pc, uut.pcpu.id_ir, uut.pcpu.reg_A, uut.pcpu.reg_B, uut.pcpu.reg_C,
         uut.pcpu.d_addr, uut.pcpu.d_dataout, uut.pcpu.ALUo, uut.pcpu.d_we, uut.pcpu.reg_C1, uut.pcpu.gr[1], uut.pcpu.gr[2], uut.pcpu.gr[3],
          uut.pcpu.gr[4], uut.pcpu.gr[5], uut.pcpu.gr[6],
          uut.pcpu.gr[7], uut.pcpu.cin, uut.pcpu.nf, uut.pcpu.zf);

        // Wait 100 ns for global reset to finish
        #100;
      $display("pc:      id_ir:    regA:regB:regC:da:dout:ALUo:dwe:reC1: gr1:gr2:gr3: gr4: gr5: gr6: gr7: cf:nf:zf");        
        // Add stimulus here
        #10 reset <= 0;
      #10 reset <= 1; 
      #10 enable <= 1;
      #10 start <=1;
        #10 start <= 0;
        #100;   

    end

endmodule

可以安装modelsim来跑跑这个代码，欢迎大家来交流更好的想法。有啥不懂的可以私聊我，虽然我不一定能及时回复。

zhidalishen
关注
  • 6
    点赞
  • 踩
  • 55
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
MIPS五级流水线CPU(verilog实现)
12-07
计算机组成原理课程实验：一个MIPS五级流水线CPU 内含全部源代码和实验文档，verilog实现，开发平台为ISE
MIPS五级流水线_实验代码.zip
06-28
1)用硬件描述语言（Verilog）设计MIPS流水线CPU，支持如下指令集： {add,addi,addiu,addu,and,andi,beq,bne,divu,j,jal,jr,lb,lbu ,lhu,lui, lw,multu,mfhi,mflo,or,ori,slt,slti,sltu,sll,sra,srl,sb,sh,sw,sub,sub} 2)用仿真软件Modelsim对有数据冒险和控制冒险的汇编程序进行仿真。
verilog 设计流水线CPU
Delicate02的博客
04-28 1333
/ 000000 00010 00010 00011 00000 100000 //2.add rs=2（8） + rt=2（8），存放到rd=3（16） //数据冒险1 与 指令 1。// 000000 00011 00011 00100 00000 100000 //3.add rs=3（16） + rt=3（16），存放到rd=4 //数据冒险2，rs=上一个rd。// 000010 00000 00000 00000 00000 000000 //16.j 无条件跳转到目标地址（绝对地址=0）。
Verilog实现MIPS的5级流水线cpu设计（Modelsim仿真）
热门推荐
WXY19990803的博客
01-16 2万+
Verilog实现IMPS的5级流水线cpu设计 本篇文章是在功能上实现cpu设计，而非结构上实现。结构上实现可以跳转到（此为个人推荐）： Verilog流水线CPU设计（超详细） 此外有与本文章配套的资源，文章中不懂的地方可以跳转到： IMPS五级流水线cpu的制作 一、实验内容 1.1：实验目的 （1）CPU各主要功能部件的实现 （2）CPU的封装 （3）了解提高CPU性能的方法 （4）掌...
基于Verilog的mips指令集单周期/五级流水cpu，modelsim/vivado仿真设计 原创设计
m0_52560903的博客
03-21 4589
我基于mips指令集设计了一个单周期cpu，在此基础上添加了流水线，在modelsim、vivado上均能仿真运行，供大家学习参考
verilog实例-流水线（Pipeline）
deilt
10-30 7121
所谓流水线设计实际上是把规模较大、层次较多的组合逻辑电路分为几个级，在每一级插入寄存器组并暂存中间数据。K级的流水线就是从组合逻辑的输入到输出恰好有K个寄存器组（分为K 级，每一级都有一个寄存器组），上一级的输出是下一级的输入而又无反馈的电路。流水线本质上可以理解为一种以面积换性能（ Trade Area for Performance ）、以空间换时间（ Trade Space for Timing ）的手段流水线设计在性能上的提高是以消耗较多的寄存器资源为代价的。
verilog实现的五级流水简易CPU（带板极验证）
老妪的备忘录
05-28 1万+
实现一个简易的五级流水的CPU，解决Hazard，并实现板极验证。     1 设计总览 2 实现原理 根据Top view 将整个CPU分为3个模块：    1 PCPU 主要模块：用从指令内存得到的指令进行运算处理，并从数据内存中写入或读取数据。这是最核心的部分，其他模块都很好设计。    2 Instruction_Mem 指令模块：
基于Verilog实现mips五级流水线CPU设计【100013168】
08-11
1）五级整数流水线，分别是：取指、译码、执行、访存、回写 2）哈佛结构，分开的指令、数据结构 3）32 个 32 位整数寄存器 4）大端模式 5）向量化异常处理，支持精确的异常处理 6）支持 6 个外部中断 7）具有 ...
md5全流水verilog实现——64级流水线
07-03
MD5全流水线Verilog实现是一种高效的硬件设计技术，用于加速MD5（Message-Digest Algorithm 5）哈希计算过程。MD5是一种广泛使用的加密散列函数，产生一个128位（16字节）的散列值，通常表示为32个十六进制数字。在...
基于MIPS32的5级流水CPU的设计、实现与应用
最新发布
05-17
利用前递技术（阻塞和前馈机制）处理5级流水线中的结构冲突和数据冲突（RAW、WAW、WAR）,最大限度地实现5级流水功能 使用Verilog语言实现5级流水CPU 使用MIPS32汇编实现带括号的四则运算计算器，并实现对表达式错误...
静态5级流水 MIPS CPU实现.rar
11-30
1 实验材料-静态5级流水 MIPS CPU实现.docx 实验内容文档 2 体系结构实验课_V1.ppt 讲解PPT 3 报告模板.docx 报告封皮 4 Basys3实验指导手册-V1.0.pdf basys3 板卡资料 5 verilog示例代码rtl_code ppt...
应用背景 Verilog 实现 MIPS32 V1整数指令集， 5级流水线CPU 没有文档，按照流水线划分模块，代码注释多，便于
03-10
应用背景 Verilog 实现 MIPS32 V1整数指令集， 5级流水线CPU 没有文档，按照流水线划分模块，代码注释多，便于理解。FPGA验证通过，可综合。 关键技术五级流水线MIPS处理器verilog源码，实现MIPS32的整数指令，代码...
Verilog流水线设计
塔克拉玛与大兴安岭的博客
04-15 1746
流水线概述 如下图为工厂流水线，工厂流水线就是将一个工作（比如生产一个产品）分成多个细分工作，在生产流水线上由多个不同的人分步完成。这个待完成的产品在流水线上一级一级往下传递。 比如完成一个产品，需要8道工序，每道工序需要10s，那么流水线启动后，不间断工作的话，第一个产品虽然要80s才完成，但是接下来每10s就能产出一个产品。使得速度大大提高。当然这也增加了人员等资源的付出。 对于电路的流水线...
RISC五级流水线CPU设计verilog仿真
diaojiangxue的博客
03-29 1705
名称：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。
自己动手写CPU（4）解决流水线数据相关+逻辑、移位操作和空指令的实现
Here is prician
05-06 5039
流水线数据相关指的是在流水线中执行的几条指令中，一条指令依赖于前面指令的执行结果
现代计算机体系结构学习
IC_see
12-13 3693
1.计算机结构概述 1.1冯·诺依曼结构   1.1.1特点        程序由指令组成并和数据一起存放在存储器中，机器按程序指定的逻辑顺序，把指令从存储器中读出来并逐条执行，从而自动完成程序描述的处理工作。 1.1.2优点        结构简单、成本低 1.1.3缺点        传统的冯诺依曼结构由于一次执行要分别进行取指令和数据，需要多次访问存储，对性能有影响。 ...
CPU的组成结构及其原理（二）
a514371309的专栏
11-11 1万+
4.再说些CPU的事情 让我试着用图片总结一下前面的基础知识。。 上图概括了CPU和计算机其他部分的互动方式。该图与实际的计算机有很大差距，but you get the idea...现在让我们把注意力集中在CPU身上！ CPU只知道执行指令，而指令是在内存里的(实际上不一定，但是为了让事情简单些，我们假设指令都是在内存里的)。所以CPU需要从内存里取出指令，这一步叫做提取(F
计算机组成原理
weixin_44972129的博客
10-07 2811
计算机性能评价 计算机有两种不同的性能度量 time to do the task 响应时间：完成单个任务所需要的的时间 执行时间 等待时间或延迟 tasks per day,hour,sec,ns… 吞吐率：单位时间所完成的任务总量 带宽 ...
【Verilog教程】6.7 Verilog流水线
高山
09-27 389
依次类推，只要衣服批次不停的输入，4 台洗衣设备即可不间断的完成对所有衣服的清洗过程。而且很多时候有些计算并不能在一个或两个时钟周期内执行完毕，如果每次输入的串行数据都需要等待上一次计算执行完毕后才能开启下一次的计算，那效率是相当低的。就像之前所说，Verilog 描述的是硬件电路，直接用乘号完成相乘过程，编译器在编译的时候也会把这个乘法表达式映射成默认的乘法器，但其构造不得而知。数据在时钟驱动下不断串行输入，乘法输出结果延迟了 4 个时钟周期后，也源源不断的在每个时钟下无延时输出，完成了流水线式的工作。
verilog 5级流水线cpu mips指令
05-12
Verilog是一种硬件描述语言，能够描述数字电路的结构与行为。而MIPS（Microprocessor without Interlocked Pipeline Stages）指令集架构，则是一种RISC（Reduced Instruction Set Computing）架构的CPU。因此，Verilog可以用于实现MIPS指令集架构的CPU，为了提高运行效率，可以将CPU设计为5级流水线的结构。 5级流水线CPU包括指令获取、指令解码、执行、访存和写回5个阶段。在指令获取阶段，CPU从存储器中获取指令。在指令解码阶段，CPU解码指令，并对指令进行分析，以确定所需的操作类型和操作数。在执行阶段，CPU执行指令，并将结果存储在寄存器中。在访存阶段，CPU从存储器中读取或写入数据。最后，在写回阶段，CPU将执行的结果写回寄存器文件，以供下一条指令使用。 设计5级流水线CPU需要考虑到各阶段之间的数据依赖关系和冲突，以避免数据读写冲突带来的延迟。除此之外，还需要考虑异常处理和中断处理机制，以保证CPU的稳定性和可靠性。 总之，基于Verilog的5级流水线CPU实现MIPS指令集架构，可以大大提高CPU的运行效率和性能，为计算机和嵌入式系统提供更好的处理能力。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值