verilog搭建单周期CPU与流水线CPU

已于 2022-08-08 11:25:10 修改
阅读量3.5k 收藏 88
点赞数 5
文章标签： fpga开发 verilog 经验分享
于 2022-07-23 19:34:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50952205/article/details/125951236
版权

目录

实现功能与搭建环境介绍

本项目基于miniRISC-V指令集，实现其中的18条指令。
工具：vivado2018.3
最终实现单周期CPU频率为25MHz，流水线CPU停留在理论阶段（呃），欢迎探讨：
在这里插入图片描述

单周期CPU

整体框图

单周期CPU就是说一个时钟周期内完成CPU的所有动作：
在这里插入图片描述
各模块具体功能：
在这里插入图片描述

具体代码

顶层模块

module cpu(
    input clk,
    input reset,
    output [31:0] segment
    );
    
    wire clk_lock;
    wire p11_clk;
    
    wire [31:0] inst;               // 指令
    wire [31:0] next_pc;            // 下一条指令位置
    wire [31:0] current_pc;         // 当前指令位置 
    
    wire [1:0] npcOp;               // 下一条指令选择信号
    wire [1:0] WSel;                // 写回内容选择信号
    wire RegWEn;                    // 控制寄存器堆读写
    wire [2:0] ImmSel;              // 立即数选择信号
    wire BSel;                      // B操作数选择信号
    wire BrLt;                      // 分支控制判断信号：是否小于
    wire BrEq;                      // 分支控制判断信号：是否等于    
    wire [3:0] ALUSel;              // ALU选择信号
    wire MemRW;                     // 控制数据存储器的读写
    
    wire [31:0] imm;                // 输入的扩展后的立即数
    wire [31:0] data1;              // rs1存储的内容
    wire [31:0] data2;              // rs2存储的内容
    wire [31:0] dataW;              // 将要存入rd的内容
    wire [31:0] data_b;             // 操作数B
    wire [31:0] data_a;             // 操作数A
    wire [31:0] result;             //ALU计算结果
    wire [31:0] data_from_mem;//来自存储器的数据

    
    // dataW三路选择器：来自DRAM/ALU/PC+4
   assign dataW = (WSel == 2'b00)?(data_from_mem):
                   ((WSel == 2'b01)?(result):
                   ((WSel == 2'b10)?(current_pc+4):2'b00));
                   
   // 选择操作数B：来自data2/imm
   assign data_b = (BSel == 0)?data2:imm;
   assign data_a = data1;
    
    // 分频模块100MHz->25MHz
    cpuclk UCLK (
        .clk_in1 (clk),
        .locked (clk_lock),
        .clk_out1 (p11_clk)
    );
    
   // NPC单元
   npc NPC (
    .clk(p11_clk),
    .reset(reset),               
    .npcOp_i(npcOp),          
    .imm_i(imm),    
    .ra_i(data1),                   
    .next_pc_o(next_pc),
    .current_pc_o(current_pc) 
   ); 
   
   // IM
   prgrom U0_irom (
    .a (current_pc[15:2]),
    .spo (inst)
   );
   
   // RF
   rf RF (
    .clk(p11_clk),
    .reset(reset),
    .RegWEn_i(RegWEn),           
    .rs1_i(inst[19:15]),
    .rs2_i(inst[24:20]),
    .rd_i(inst[11:7]),
    .data_w_i(dataW),
    .data1_o(data1),
    .data2_o(data2)
   );
   
   // IMME
   imme IMME (
    .clk(p11_clk),
    .reset(reset),
    .imm_i(inst[31:7]),
    .ImmSel_i(ImmSel),    
    .imm_o(imm)
   );
   
   // ALU
   alu ALU (
    .clk(p11_clk),
    .reset(reset),
    .data_a_i(data_a),
    .data_b_i(data_b),
    .ALUOp_i(ALUSel),                 
    .BrEq_o(BrEq),               
    .BrLt_o(BrLt),                 
    .data_r_o(result)               
   );
   
  // DRAM   
   data_mem dram (
    .clk(p11_clk),
    .addr_i(result),
    .data_w_i(data2),
    .MemRW(MemRW),
    .data_r_o(data_from_mem),
    
    .segment(segment)
);

   // CU
   cu CU (
    .clk(p11_clk),
    .reset(reset),
    .inst(inst),
    .BrLt_i(BrLt),
    .BrEq_i(BrEq),
    .NPCOp_o(npcOp),
    .RegWEn_o(RegWEn),
    .WSel_o(WSel),
    .ImmSel_o(ImmSel),
    .BSel_o(BSel),
    .ALUSel_o(ALUSel),
    .MemRW_o(MemRW)
   );
 
endmodule

取值

NPC模块：

module npc(
    input clk,
    input reset,                // 复位信号
    input [1:0] npcOp_i,          // npc选择信号
    input [31:0] imm_i,           // 输入的立即数，用于jal,jalr,B型指令的跳转
    input [31:0] ra_i,                   // rs1，用于jalr的跳转
    output wire [31:0] next_pc_o,
    output reg [31:0] current_pc_o
    );
    
    //下一条pc有三种选择：
    //npc = pc+4    'b00
    //npc = pc+imm  'b01
    //npc = rs1+imm 'b10
    
    assign  next_pc_o = (npcOp_i == 2'b00)?(current_pc_o+4):
                       ((npcOp_i == 2'b01)?(current_pc_o+imm_i):
                       ((npcOp_i == 2'b10)?(ra_i+imm_i):32'b0));

    
    always@ (posedge clk) begin
        if (reset == 0) begin
            current_pc_o <= -4;
        end else begin
            current_pc_o <= next_pc_o;
        end
    end
    
endmodule

IM模块：取指单元包含了存放miniRV-1汇编程序的程序ROM (Instructioin ROM, IROM)。我们需要使用Vivado自带的存储IP核Distributed Memory Generator来定义IROM。（也可以自己写）

译码

RF模块：

module rf(
    input clk,
    input reset,
    input RegWEn_i,           //  写使能信号。高电平写，低电平读
    input [4:0] rs1_i,
    input [4:0] rs2_i,
    input [4:0] rd_i,
    input [31:0] data_w_i,
    
    output [31:0] data1_o,
    output [31:0] data2_o
    );
    
    reg [31:0] regFile[0:31];       // 32个寄存器
    integer i;
    
    assign data1_o = regFile[rs1_i];
    assign data2_o = regFile[rs2_i];
    
    always@ (posedge clk) begin
        if (reset == 0) begin
            for (i = 0;i < 32;i = i+1)
                regFile[i] <= 0;
        end else if (RegWEn_i != 0 && rd_i != 0) begin
            regFile[rd_i] <= data_w_i;
        end
    end 
    
endmodule

IMME模块：

module imme(
    input clk,
    input reset,
    input [24:0] imm_i,
    input [2:0] ImmSel_i,    
    output wire [31:0] imm_o
    );
    
    wire [31:0] imm_wire;

    assign imm_wire = (ImmSel_i == 3'b000)?({{11{imm_i[24]}},imm_i[24],imm_i[12:5],imm_i[13],imm_i[23:14],1'b0}):
                       ((ImmSel_i == 3'b001)?({{20{imm_i[24]}},imm_i[24:13]}):
                       ((ImmSel_i == 3'b010)?({{20{imm_i[24]}},imm_i[24:18],imm_i[4:0]}):
                       ((ImmSel_i == 3'b011)?({{12{imm_i[24]}},imm_i[24:5]}):
                       ((ImmSel_i == 3'b100)?({{19{imm_i[24]}},imm_i[24],imm_i[0],imm_i[23:18],imm_i[4:1],1'b0}):32'b0))));

    assign imm_o = imm_wire; 

endmodule

CU模块：

module cu(
    input clk,
    input reset,
    input [31:0] inst,
    input BrLt_i,
    input BrEq_i,
    output reg [1:0] NPCOp_o,
    output reg RegWEn_o,
    output reg [1:0] WSel_o,
    output reg [2:0] ImmSel_o,
    output reg BSel_o,
    output reg [3:0] ALUSel_o,
    output reg MemRW_o
    );
    
    wire [6:0] funct7;
    wire [2:0] funct3;
    wire [6:0] opcode;
    
    assign funct7 = inst[31:25];
    assign funct3 = inst[14:12];
    assign opcode = inst[6:0];
    
    always @(inst or BrEq_i or BrLt_i) begin
        if (reset == 0) begin
            RegWEn_o = 0;
            WSel_o = 0;
            ImmSel_o = 0;
            BSel_o = 0;
            MemRW_o = 0;
            NPCOp_o = 0;
            ALUSel_o = 0;
        end else begin
            case (opcode)
            7'b0110011 : begin          // R型指令
                case(funct3)             // 使用funct3与funct7判断ALUSel
                3'b000:begin
                    if (funct7[5] == 1) begin
                        ALUSel_o = 4'b0001;
                    end else begin
                        ALUSel_o = 4'b0000;
                    end
                end
                3'b111:ALUSel_o = 4'b0010;
                3'b110:ALUSel_o = 4'b0011;
                3'b100:ALUSel_o = 4'b1000;
                3'b001:ALUSel_o = 4'b0100;
                3'b101:begin
                    if (funct7[5] == 0) begin
                        ALUSel_o = 4'b0101;
                    end else begin
                        ALUSel_o = 4'b0110;
                    end
                end
                endcase
                NPCOp_o = 2'b00;
                RegWEn_o = 1;
                WSel_o = 2'b01;
                ImmSel_o = 3'b000;
                BSel_o = 0;
                MemRW_o = 0;
            end
            7'b0010011 : begin          // I型指令
                case(funct3)             // 使用funct3与funct7判断ALUSel
                3'b000:ALUSel_o = 4'b0000;
                3'b111:ALUSel_o = 4'b0010;
                3'b110:ALUSel_o = 4'b0011;
                3'b100:ALUSel_o = 4'b1000;
                3'b001:ALUSel_o = 4'b0100;
                3'b101:begin
                    if (funct7[5] == 0) begin
                        ALUSel_o = 4'b0101;
                    end else begin
                        ALUSel_o = 4'b0110;
                    end
                end
                endcase
                NPCOp_o = 2'b00;
                RegWEn_o = 1;
                WSel_o = 2'b01;
                ImmSel_o = 3'b001;
                BSel_o = 1;
                MemRW_o = 0;
            end
            7'b0000011 : begin          // load指令
                NPCOp_o = 2'b00;
                RegWEn_o = 1;
                WSel_o = 2'b00;
                ImmSel_o = 3'b001;
                BSel_o = 1;
                ALUSel_o = 4'b0000;
                MemRW_o = 0;
            end
            7'b1100111 : begin          // jalr
                NPCOp_o = 2'b10;
                RegWEn_o = 1;
                WSel_o = 2'b10;
                ImmSel_o = 3'b001;
                BSel_o = 0;
                ALUSel_o = 4'b0000;
                MemRW_o = 0;
            end
            7'b0100011 : begin          // S型指令
                NPCOp_o = 2'b00;
                RegWEn_o = 0;
                WSel_o = 2'b00;
                ImmSel_o = 3'b010;
                BSel_o = 1;
                ALUSel_o = 4'b0000;
                MemRW_o = 1;
            end
            7'b1100011 : begin          // B型指令
                case (funct3)
                3'b000:NPCOp_o = (BrEq_i == 1)?2'b01:2'b00;
                3'b001:NPCOp_o = (BrEq_i == 0)?2'b01:2'b00;
                3'b100:NPCOp_o = (BrLt_i == 1)?2'b01:2'b00;
                3'b101:NPCOp_o = (BrLt_i == 0)?2'b01:2'b00;
                endcase
                RegWEn_o = 0;
                WSel_o = 2'b00;
                ImmSel_o = 3'b100;
                BSel_o = 0;
                ALUSel_o = 4'b0001;
                MemRW_o = 0;
            end
            7'b0110111 : begin          // U型指令
                NPCOp_o = 2'b00;
                RegWEn_o = 1;
                WSel_o = 2'b01;
                ImmSel_o = 3'b011;
                BSel_o = 1;
                ALUSel_o = 4'b0111;
                MemRW_o = 0;
            end
            7'b1101111 : begin          // J型指令
                NPCOp_o = 2'b01;
                RegWEn_o = 1;
                WSel_o = 2'b10;
                ImmSel_o = 3'b000;
                BSel_o = 0;
                ALUSel_o = 4'b0000;
                MemRW_o = 0;
            end
            default: NPCOp_o <= 2'b00;
            endcase
        end
    end
    
endmodule

执行

ALU模块：

module alu(
    input clk,
    input reset,
    input [31:0] data_a_i,
    input [31:0] data_b_i,
    input [3:0] ALUOp_i,              // ALU选择信号
    
    output wire BrEq_o,                // 分支判断，判断是否相等
    output wire BrLt_o,                 // 分支判断，判断是否小于
    output wire [31:0] data_r_o               // 计算结果
    );
    
    
    // ADD-000,SUB/B-001,AND-010,OR-011,SLL-100,SRL-101,SRA-110,U型指令，左移12位-111,xor-1000
assign data_r_o = (ALUOp_i == 4'b0000)?(data_a_i + data_b_i):
                 ((ALUOp_i == 4'b0001)?(data_a_i + (~data_b_i + 1'b1)):
                 ((ALUOp_i == 4'b0010)?(data_a_i & data_b_i):
                 ((ALUOp_i == 4'b0011)?(data_a_i | data_b_i):
                 ((ALUOp_i == 4'b0100)?(data_a_i << (data_b_i[4:0])):
                 ((ALUOp_i == 4'b0101)?(data_a_i >> (data_b_i[4:0])):
                 ((ALUOp_i == 4'b0110)?($signed($signed(data_a_i) >>> (data_b_i[4:0]))):
                 ((ALUOp_i == 4'b0111)?(data_b_i <<12):
                 ((ALUOp_i == 4'b1000)?(data_a_i^data_b_i):32'b0))))))));
                 
assign BrEq_o = (ALUOp_i == 4'b0001 && data_r_o == 0)?1:0;
assign BrLt_o = (ALUOp_i == 4'b0001 && $signed(data_r_o) < 0)?1:0;

endmodule

访存

DRAM模块：

module data_mem(
    input clk,
    input [31:0] addr_i,
    input [31:0] data_w_i,
    input MemRW,
    output [31:0] data_r_o,
    
    output reg [31:0] segment	// 外设：显示管
    );
    
    wire [31:0] addr;

    assign addr = (addr_i == 32'hFFFFF000)?addr_i:(addr_i - 16'h4000);	// 0xFFFFF000为外设地址。数据存储器与指令存储器采用统一编址，因此数据存储器地址需要减去0x4000
    
     // DRAM   
   dram U_dram (
    .clk    (clk),            // input wire clka
    .a      (addr[15:2]),     // input wire [13:0] addra
    .spo    (data_r_o),        // output wire [31:0] douta
    .we     (MemRW),          // input wire [0:0] wea
    .d      (data_w_i)         // input wire [31:0] dina
);

    always @(posedge clk) begin
        segment <= (addr_i == 32'hFFFFF000 && MemRW)?data_w_i:segment;
    end
    
endmodule

这里访存模块写了一个简陋的总线，连接外设便于上板显示。
其中数据存储器模块dram使用了IP核，同样也使用Distributed Memory Generator来实现。

写回

执行目的寄存器的写入。

流水线CPU

整体框图

流水线整体设计：在这里插入图片描述
整体框图：
在这里插入图片描述
在这里插入图片描述
冲突解决模块具体设计：
在这里插入图片描述
跳转控制模块具体设计：
在这里插入图片描述

前置知识及思路探讨

如何让流水线流起来~

啊这个其实我是实现了的，就是指令跳转方面有点问题，不涉及指令跳转倒是正常。
本项目采用五级流水线，一个时钟周期执行一个阶段，所以需要在每级之间加入寄存器保存数据。即有四个流水线寄存器，因为每一级分别运行不同的指令，每条指令在各级之间呈阶梯型传递（所以叫流水线哈哈），所以我们需要考虑每级之间通过寄存器要传递什么数据。比如ID阶段得到的控制信号，在EX阶段与MEM阶段也要使用，而有些数据在此阶段已经使用完毕，所以不用再向下传递。
尝试在理论层面解决数据冲突与指令跳转问题↓

Hazard_detect模块

因为每一级分别运行不同指令，所以指令间难免冲突。
在这里插入图片描述

数据冒险：
数据冒险是指因无法提供指令执行所需数据而导致指令不能再预期的时钟周期内执行的情况。即之前指令的目的寄存器等于当前指令的源寄存器，ID阶段从源寄存器中所取内容不是期待的内容，所需数据可能停留在之前指令的EX，MEM或WB阶段，还未来得及更新。
需要解决的三种数据冒险：
① R-R1型：期待内容是之前指令ALU的计算结果。
② Load-use型：期待内容是之前指令从DRAM中读出数据。
③ R-R2型：期待内容是之前指令WB阶段的写回数据。
条件判定分别如下：
① R-R1型：EX.RegWEn && EX.rd ≠ 0 && (EX.rd == ID.rs1 || EX.rd == ID.rs2)
② Load-use型：MEM.RegWEn && MEM.rd ≠ 0 && (MEM.rd == ID.rs1 || MEM.rd == ID.rs2)
③ R-R2型：WB.RegWEn && WB.rd ≠ 0 && (WB.rd == ID.rs1 || WB.rd == ID.rs2)
解决方法分别如下：
① R-R1型：前递，运算结果直接作为操作数再次运算。
② R-R2型：前递，要写入寄存器堆中的数据直接作为读出数据。
③ Load-use型：前递+停顿一周期。停顿时需要保存PC，IF-ID寄存器模块中的内容，清除ID-EX寄存器中的内容。

控制冒险：
接收来自Jump_Cu模块的NPCOp信号，若为高电平则代表发生控制冒险，清除IF-ID，ID-EX寄存器中的内容，确保流水线正常运行。

Jump_CU模块

删除单周期流水线中的NPC模块，把涉及jal，jalr，B型指令的npc计算转移至Jump_CU模块。
输入信号Jump[0]区分是否为跳转指令，Jump[1]区分是否为无条件跳转，Jump[2:4]区分为jal，jalr或B型指令中的一种。若输入Jump[0]为0，则当前指令不涉及指令跳转，输出NPCOp为低电平，反之进一步判断；若Jump[1]为1，则为jal，jalr的无条件跳转，输出NPCOp为高电平；反之Jump[1]为0，则为B型指令的有条件跳转，进一步根据ALU模块计算得来的BrLt信号与BrEq信号判定是否需要跳转，若是则输出NPCOp为高电平，反之为低电平。
输出的NPCOp信号交给Hazard_Detect模块，为高电平则代表发生控制冒险，清除IF-ID，ID-EX寄存器中的内容，将计算出的正确npc指令传递给PC模块，运行正确指令。
但是B型指令需要ALU的执行结果判断是否满足条件跳转，jal与jalr可以不用在EX阶段才判断，可以在ID阶段就进行跳转。

海心巧克力
关注
单周期CPU及流水线CPU设计（1）---logisim部件设计
TONNE_YANG的专栏
12-27 2万+
logisim的设计是设计CPU的基础，在往后的CPU的代码书写的过程中必然时刻伴随着设计图纸的需求。 （如有转载，请注明出处，否则将追究） （1）基本介绍 Logisim 允许用户使用图形用户接口设计并仿真数字电路，它自身包含一些库，库中已有诸如基础门电路，存储器、多路选择器、译码器等简单器件。在后续的实验中，你将使用这些器件搭建自己的 CPU。在本实验中，我们将在 logis
流水线CPU Verilog设计
12-23
流水线CPU 包括转发暂停等功能，支持mips除eret ，mtc0，mfc0外所有指令(包括乘除运算，读写hi lo，取字节等等）乘除分别需要5，10个周期，代码能通过测试。
用Verilog设计1个单周期CPU
最新发布
m0_64363794的博客
01-05 2118
而在写操作时，在 We使能信号为1时，在时钟边沿触发写入。we：写使能信号，We为1时，进行sw指令操作，此时Din端口输入信号实际为rt，Addr端口输入信号为rs和偏移量相加的地址，在时钟周期上升沿将rt的值写入改地址的储存单元；Wr：写使能信号，为0的时候不能写入，D值不更新，为1的时候能写入，D值更新（当时钟边沿到来时，将𝐷𝑎𝑡𝑎端口送来的数据写入𝑅𝑤指定的寄存器）入信号。因此，要设计处理器，首先需要确定处理器的指令集和指令编码，然后确定每条指令的数据通路，最后确定数据通路的控制信号。
【Verilog设计】8位CPU
LionelZhao的博客
05-07 2412
设计了一个单核顺序执行支持16条指令的简易8位CPU，无中断和异常处理、无流水线并行、无乱序执行等高效计算技术。该处理器支持内存读写、寄存器读写、跳转指令及常见的算数、逻辑运算，片上集成了16Byte的寄存器组，可拓展为GPIO用于控制常见的外设。
简单CPU的Verilog设计
01-12
本资料中包含了运算器ALU的设计源码、存储器的设计源码、控制器的设计源码、还有CPU的整体设计源码
verilog实现的流水线CPU
06-10
通过verilog语言实现的流水线CPU的源文件、工程文件，已通过仿真和下载验证。
计组头歌实验：MIPS单周期CPU设计(24条指令)(HUST)1-4关源码
07-03
然而，这样的设计有助于理解CPU工作原理，为后续学习多周期CPU和流水线CPU打下基础。通过实践，学生可以深入掌握数字逻辑、微体系结构和计算机组织等核心概念。 综上所述，MIPS单周期CPU设计是计算机系统课程中的...
single-cycle-cpu：单周期RISC-V微处理器
02-22
在更复杂的处理器设计中，通常会采用多周期或流水线CPU架构来提高效率。 总的来说，“single-cycle-cpu”项目提供了学习和实践RISC-V处理器设计的宝贵资源，对于理解计算机硬件工作原理以及Verilog语言的应用具有很...
Project6 VerilogHDL开发多周期处理器.pdf
07-03
- "多周期CPU" 是项目的核心，多周期处理器设计通常比单周期处理器更复杂，但能提供更好的性能和控制。 - "mips" 是MIPS（Microprocessor without Interlocked Pipeline Stages）架构，一种流行的精简指令集计算机...
RIJ_CPU_32位单周期_RIJ型CPU_RIJ_CPU实验_2654cpU_RIJ_CPU_源码.zip
09-30
在32位单周期CPU中，“32位”指的是CPU的数据总线宽度，意味着它可以一次性处理32位的数据，这通常对应于现代计算机的个人或服务器级应用。这样的宽度允许处理器处理更大的地址空间（2^32个地址），同时进行更高效的...
Verilog 单周期CPU
04-14
自己设计的单周期CPU,可以直接运行查看结果。
简单基本流水线CPU设计VerilogHDL（含源代码+报告+原理图）
07-03
简单基本流水线CPU设计VerilogHDL（含源代码+报告+原理图） 简单的流水线CPU，报告原始设计图，VerilogHDL语言的代码，已经Quartus工程项目 设计文档等等
基于verilog的多周期CPU设计
08-08
本项目主要利用Verilog语言设计一一个基于MIPS架构的CPU。分别设计指令存储器、寄存器堆、ALU、取指令部件、数据存储器、立即数处理单元、主单元控制器、ALU控制单元。将这些单元连城数据通路，再结合控制单元合成CPU下板验证。并基于该cpu完成了串口收发数据的驱动，并下板测试，功能正确。该代码是基于EP4CE10F17C8开发板的，可直接下板，其他开发板只需稍做改变即可用
简易CPU之verilog设计（原创）
09-08
当年交的单周期CPU设计作业，现在看来挺烂的 好的先不发
单周期cpuVerilog实现
05-11
单周期cpuVerilog实现，sc_computer
Verilog实现单周期CPU(部分MIPS指令集的指令)
AlexZhang67的博客
12-14 9623
这学期比较忙，很久没发博客了，先附上源码，等过完期末再补全博文 源码链接：https://github.com/AlexZhang267/Single-Cycle-CPU 注：我是在编辑器中写的，用Icarus Verilog编译运行的，没用vivado。单周期，没有pipeline，太简单了。。。不想写说明了，就是对着这张图写的。
使用Verilog搭建一个单周期CPU
qq_45551930的博客
12-04 2606
使用Verilog搭建一个单周期CPU 搭建篇 总体结构 其实跟使用logisim搭建CPU基本一致，甚至更简单，因为完全可以照着logisim的电路图来写，各个模块和模块间的连接在logisim中非常清楚。唯一改变了的只有GRF和DM要多一个input PC端口，用来display的时候输出PC值；IFU同理多了一个output PC，用来把PC的值传给GRF和DM。其他的模块我都是直接对着logisim原封不动地用Verilog重新实现了一遍。目前支持指令集{addu、subu、ori、lw、sw、be
verilog——简单cpu
qq_57221504的博客
12-30 4946
数电课程设计 verilog代码 module top(input clock,input reset,output sum,output [15:0]instruction,output [3:0]u,output [3:0]s);//顶层程序，将后面每一个模块进行连线 wire [15:0]instruction; wire [3:0]sum; wire a; wire[7:0]c; wire d,e,f; wire [3:0]g; wire h; wire [3:0]i; wire j; wire
基于Verilog的流水线CPU设计
qq_45945307的博客
06-23 2266
MIPS五级流水线CPU设计。
Verilog实现简易单周期CPU及实验报告教程
资源摘要信息: "基于Verilog的简易单周期CPU的实现+实验报告.zip" 本资源包含了一系列文件，旨在提供给计算机相关专业的学生、教师和从业人员一个简易单周期CPU的设计实现案例。该资源着重于硬件描述语言Verilog的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值