Verilog HDL语言实现的单周期CPU设计（全部代码及其注释）

写在前面：本博客为本人原创，严禁任何形式的转载！本博客只允许放在博客园（.cnblogs.com），如果您在其他网站看到这篇博文，请通过下面这个唯一的合法链接转到原文！

本博客全网唯一合法URL：http://www.cnblogs.com/acm-icpcer/p/9289857.html

（1）shift：

module shift (d,sa,right,arith,sh);
input  [31:0]  d;
input  [4:0]     sa;
input  right,arith;
output [31:0] sh;
reg  [31:0] sh;
always  @*  beginif   (!right)  begin                        //shift leftsh = d << sa;end else  if   (!arith)  begin              //shift right logicalsh =  d  >>  sa;end else begin                              //shift right arithmeticsh =  $signed(d)  >>>  sa;end
end
endmodule

移位器，<<表示向左移，>>表示向右移，>>>表示无符号向右移，sa表示向右移的位数。因为做多移动32位，所以sa用5位寄存器表示。

图一

（2）scinstmem（图一左边蓝圈）：

module scinstmem (a,inst); input [31:0] a; output [31:0] inst; wire [31:0] rom [0:31];assign    rom[5'h00] = 32'h3c010000;    //    (00)    main: lui r1,0assign    rom[5'h01] = 32'h34240050;    //    (04)        ori r4,r1,80assign    rom[5'h02] = 32'h20050004;    //    (08)        addi r5,r0, 4assign    rom[5'h03] = 32'h0c000018;    //    (0c)    call: jal sumassign    rom[5'h04] = 32'hac820000;    //    (10)        sw r2,0(r4)assign    rom[5'h05] = 32'h8c890000;    //    (14)        lw    r9,    0(r4)assign    rom[5'h06] = 32'h01244022;    //    (18)        sub    r8,    r9.    r4assign    rom[5'h07] = 32'h20050003;    //    (lc)        addi    r5,    r0.    3assign    rom[5'h08] = 32'h20a5ffff;    //    (20)    loop2:    addi    r5,    r5,    -1assign    rom[5'h09] = 32'h34a8ffff;    //    (24)        ori    r8,    r5,    0xffffassign    rom[5'h0A] = 32'h39085555;    //    (28)        xori    r8.    r8,    0x5555assign    rom[5'h0B] = 32'h2009ffff;    //    (2c)        addi    r9,    rO,    -1assign    rom[5'h0C] = 32'h312affff;    //    (30)        andi    rlO,    r9,    0xffffassign    rom[5'h0D] = 32'h01493025;    //    (34)        or    r6.    rlO,    r9assign    rom[5'h0E] = 32'h01494026;    //    (38)        xor    r8,    rlO,    r9assign    rom[5'h0F] = 32'h01463824;    //    (3c)        and    r7,    rlO,    r6assign    rom[5'h10] = 32'h10a00001;    //    (40)        beq    r5,    r0,    shiftassign    rom[5'h11] = 32'h08000008;    //    (44)        j    loop2    assign    rom[5'h12] = 32'h2005ffff;    //    (48)    shift:    addi    r5.    r0,    -1assign    rom[5'h13] = 32'h000543c0;    //    (4c)        sll    r8.    r5.    15assign    rom[5'h14] = 32'h00084400;    //    (50)        sll    r8,    r8,    16assign    rom[5'h15] = 32'h00084403;    //    (54)        sra    r8,    r8,    16assign    rom[5'h16] = 32'h000843c2;    //    (58)        srl    r8.    r8.    15assign    rom[5'h17] = 32'h08000017;    //    (5c)    finish:    j    finish    assign    rom[5'h18] = 32'h00004020;    //    (60)    sum:    add    r8,    r0,    r0assign    rom[5'h19] = 32'h8c890000;    //    (64)    loop:    lw    r9,    (r4)assign    rom[5'h1A] = 32'h20840004;    //    (68)        addi    r4,    r4,    4assign    rom[5'h1B] = 32'h01094020;    //    (6c)        add    r8,    r8,    r9assign    rom[5'h1C] = 32'h20a5ffff;    //    (70)        addi    r5,    r5,    -1assign    rom[5'h1D] = 32'h14a0fffb;    //    (74)        bne    rS,    r0,    loopassign    rom[5'h1E] = 32'h00081000;    //    (78)        sll    r2f    r8f    0assign    rom[5'h1F] = 32'h03e00008;    //    (7c)        jr    r31        assign    inst = rom[a[6:2]];endmodule

只读指令存储器，用于存放存储的程序，用32个32位寄存器表示，每一个寄存器存储一条指令的机器语言格式（用8位16进制代码表示32位2进制代码，每一条机器指令后面的注释是它的汇编格式）。a用于存放本指令周期内寄存器pc的值，output用于存放即将要执行的寄存器pc所指向的指令所在的寄存器编号。这就是为什么要在最后加上代码：assign inst = rom[a[6:2]];实际上，a[6:2]所代表的就是pc内容格式所表示的寄存器号码的字段。

（3）scdatamem（图一右边蓝圈）：

module scdatamem (clk,dataout,datain,addr,we,inclk,outclk);
input    [31:0]    datain;
input    [31:0]    addr ;
input        clk, we, inclk, outclk;
output    [31:0]    dataout;
reg [31:0] ram    [0:31];
assign    dataout    =ram[addr[6:2]];
always @ (posedge clk) beginif (we) ram[addr[6:2]] = datain;
end
integer i;
initial beginfor (i = 0;i < 32;i = i + 1)ram[i] = 0;ram[5'h14] = 32'h000000a3;ram[5'h15] = 32'h00000027;ram[5'h16] = 32'h00000079;ram[5'h17] = 32'h00000115;
end
endmodule

we表示写使能，由图一可知，此项信号由控制器负责译码传输过来，故而if (we) ram[addr[6:2]] = datain;表示当有写使能的，通过输入的addr数据的寄存器字段指定相应的32位寄存器，并将输入的数据datain写入数据存储器内的相应的ram部分。always @ (posedge clk) begin表示始终在上升沿的时候触发写ram。后面的：

initial begin

for (i = 0;i < 32;i = i + 1)

ram[i] = 0;

ram[5'h14] = 32'h000000a3;

ram[5'h15] = 32'h00000027;

ram[5'h16] = 32'h00000079;

ram[5'h17] = 32'h00000115;

end

与存储在指令存储器内的汇编源代码的具体意义相关，先不分析了。

（4）sccu_dataflow（控制器译码模块）：

module sccu_dataflow (op,func,z,wmem,wreg,regrt,m2reg,aluc,shift,aluimm,pcsource,jal,sext);input [5:0] op,func;input z;output wreg,regrt,jal,m2reg,shift,aluimm,sext,wmem;output [3:0] aluc;output [1:0] pcsource;wire r_type = ~|op;wire i_add = r_type&func[5]&~func[4]&~func[3]&~func[2]&~func[1]&~func[0];wire i_sub = r_type&func[5]&~func[4]&~func[3]&~func[2]&func[1]&~func[0];wire i_and = r_type&func[5]&~func[4]&~func[3]&func[2]&~func[1]&~func[0];wire i_or = r_type&func[5]&~func[4]&~func[3]&func[2]&~func[1]&func[0];wire i_xor = r_type&func[5]&~func[4]&~func[3]&func[2]&func[1]&~func[0];wire i_sll = r_type&~func[5]&~func[4]&~func[3]&~func[2]&~func[1]&~func[0];wire i_srl = r_type&~func[5]&~func[4]&~func[3]&~func[2]&func[1]&~func[0];wire i_sra = r_type&~func[5]&~func[4]&~func[3]&~func[2]&func[1]&func[0];wire i_jr = r_type&~func[5]&~func[4]&func[3]&~func[2]&~func[1]&~func[0];wire i_addi = ~op[5]&~op[4]&op[3]&~op[2]&~op[1]&~op[0];wire i_andi = ~op[5]&~op[4]&op[3]&op[2]&~op[1]&~op[0];wire i_ori = ~op[5]&~op[4]&op[3]&op[2]&~op[1]&op[0];wire i_xori = ~op[5]&~op[4]&op[3]&op[2]&op[1]&~op[0];wire i_lw = op[5]&~op[4]&~op[3]&~op[2]&op[1]&op[0];wire i_sw = op[5]&~op[4]&op[3]&~op[2]&op[1]&op[0];wire i_beq = ~op[5]&~op[4]&~op[3]&op[2]&~op[1]&~op[0];wire i_bne = ~op[5]&~op[4]&~op[3]&op[2]&~op[1]&op[0];wire i_lui = ~op[5]&~op[4]&op[3]&op[2]&op[1]&op[0];wire i_j = ~op[5]&~op[4]&~op[3]&~op[2]&op[1]&~op[0];wire i_jal = ~op[5]&~op[4]&~op[3]&~op[2]&op[1]&op[0];assign wreg = i_add|i_sub|i_and|i_or|i_xor|i_sll|i_srl|i_sra|i_addi|i_andi|i_ori|i_xori|i_lw|i_lui|i_jal;assign regrt= i_addi|i_andi|i_ori|i_xori|i_lw|i_lui;assign jal= i_jal;assign m2reg= i_lw;assign shift=i_sll|i_srl|i_sra;assign aluimm=i_addi|i_andi|i_ori|i_xori|i_lw|i_lui|i_sw;assign sext =i_addi|i_lw|i_sw|i_beq|i_bne;assign aluc[3]=i_sra;assign aluc[2]=i_sub|i_or|i_srl|i_sra|i_ori|i_lui;assign aluc[1]=i_xor|i_sll|i_sra|i_xori|i_beq|i_bne|i_lui;assign aluc[0]=i_and|i_or|i_sll|i_srl|i_sra|i_andi|i_ori;assign wmem = i_sw;assign pcsource[1]=i_jr|i_j|i_jal;assign pcsource[0]=i_beq&z|i_bne&~z|i_j|i_jal;
endmodule

图二

此乃控制器译码部分。前面的20条wire语句对应于前面的mips指令集，其中的前10条是R型指令，其主要是先判断是否是R型，如果是，再通过最后面的function字段判断到底是哪一条R型指令；后面的10条wire语句就可以直接通过op字段判断出是哪一条MIPS指令。判断出是什么指令了就要进行译码，并输出控制信号，代码最后面的一堆assign就是干这个事情的。

图三

现在取出几条代码来说明assign语句如何工作的：

1）

2）

assign pcsource[1]=i_jr|i_j|i_jal;

assign pcsource[0]=i_beq&z|i_bne&~z|i_j|i_jal;

两条pcsource赋值语句用于告诉四选一选择器判断到底是用哪一条数据来源进行对pc值（下一条待执行的代码段地址）的修改。例如：如果当前指令是跳转指令时，那么就要通过读取寄存器对的内容或者

通过alu的计算来获得下一条指令的地址。

3）

assign aluc[3]=i_sra;

如果当前的指令是要用到alu的指令时，就要判断具体要让alu进行说明操作，故而要产生一些传递给alu的控制信号。

其余的assign指令不赘述，思想大同小异。

（5）sccpu_dataflow：

module  sccpu_dataflow(clock, resetn, inst,mem,pc, wmem,alu,data);
input     [31:0]   inst,mem;
input         clock,resetn;
output   [31:0]  pc,alu,data;output wmem;
wire  [31:0] p4 , bpc, npc, adr, ra, alua, alub, res, alu_mem;
wire  [3:0] aluc;
wire  [4:0] reg_dest, wn;
wire  [1:0] pcsource;
wire  zero, wmem, wreg, regrt, m2reg, shift, aluimm, jal, sext;
wire  [31:0]  sa  =  {27'b0,inst[10:6]};
wire  [31:0]  offset  =  {imm[13:0],inst[15:0],2'b00};
sccu_dataflow cu  (inst[31:26] , inst[5:0] , zero, wmem,wreg,regrt,m2reg, aluc, shift, aluimm,pcsource, jal, sext);
wire   e  =  sext  &  inst[15];
wire   [15:0]       imm =  {16{e}};
wire  [31:0]       immediate  =  {imm,inst[15:0]};
dff32  ip  (npc,clock,resetn,pc);
cla32  pcplus4   (pc,32'h4,1'b0,p4);
cla32  br_adr     (p4,offset,1'b0, adr);
wire  [31:0]        jpc =  {p4[31:28],inst[25:0],2'b00};
mux2x32  alu_b  (data, immediate,aluimm, alub) ;
mux2x32  alu_a  (ra,sa,shift,alua);
mux2x32  result   (alu,mem,m2reg,alu_mem);
mux2x32  link (alu_mem,p4,jal,res);
mux2x5  reg_wn   (inst[15:11], inst[20: 16] , regrt, reg_dest);
assign wn = reg_dest   |   {5{jal}};                                 //ja1:  r31  <-- p4;
mux4x32  nextpc  (p4,adr,ra, jpc,pcsource,npc);
regfile  rf   (inst[25:21] ,inst[20:16] ,res,wn,wreg,clock,resetn,ra,data);
alu  al_unit   (alua,alub,aluc,alu, zero);
endmodule

这个就是描述图三中所有的部件，以及部件之间如何传递数据的关系的模块调用代码

（6）sccmop_dataflow：

module  sccomp_dataflow(clock, resetn, inst, pc, aluout, memout,mem_clk);
input  clock, resetn,mem_clk;
output   [31:0]  inst,pc, aluout,memout;
wire [31:0]   data;
wire   wmem;
sccpu_dataflow s (clock, resetn, inst,memout,pc, wmem, aluout, data);
scinstmem imem (pc,inst);
scdatamem dmem (clock, memout, data, aluout, wmem, mem_clk, mem_clk);
endmodule

最顶层的控制模块，从代码结构可以看出其主要控制数据通路、存储好的程序和数据存储模块。

（7）regfile：

module regfile  (rna, rnb, d, wn,we, clk, clrn, qa, qb);
input       [4:0]  rna,rnb,wn;
input     [31:0]  d;
input     we, clk, clrn;
output  [31:0]  qa,qb;
reg     [31:0]  register  [1:31];  //  31  x  32-bit  regs//  2  read ports
assign qa  =   (rna ==  0) ? 0 : register[rna];
assign qb  =   (rnb ==  0) ? 0 : register[rnb];//  1  write port
always @(posedge clk or negedge clrn)
begin
if  (clrn==0)
begininteger i;for(i=1;i<32;i=i+1)register[i] <= 0;
end
else  if((wn!=0)&&we)
register[wn]  <= d;
end
endmodule

这个就是位于图三中心部分的是寄存器堆，前头部分主要是完成了对寄存器堆的定义，后面就是对寄存器堆读写的分别实现。

比如代码assign qa = (rna == 0) ? 0 : register[rna]; 就表示读出ma所指定的寄存器中的值，并输出到qa输出口。

（8）mux4x32：

module mux4x32 (a0,a1,a2,a3,s,y);input [31:0] a0,a1,a2,a3;input [1:0] s;output [31:0] y;function [31:0] select;input [31:0] a0,a1,a2,a3;input [1:0] s;case (s)2'b00: select = a0;2'b01: select = a1;2'b10: select = a2;2'b11: select = a3;endcaseendfunctionassign  y = select(a0,a1,a2,a3,s);
endmodule

四选一多路选择器，主要选择从输入的4个口中的具体选择哪一个口子数据输出。因为只有4个来源，所以只要使用两位的s来进行选择就行。代码功能就是从a1，a2，a3，a4中通过s选一个输出到y，s的内容一般由模块（4），也就是控制器译码模块决定。

（9）其余的选择器：

module mux2x5 (a0,a1,s,y);input [4:0] a0,a1;input s;output [4:0] y;assign y = s?a1:a0;
endmodulemodule mux2x32 (a0,a1,s,y);input [31:0] a0,a1;input s;output [31:0] y;assign y = s?a1:a0;
endmodule

功能与（8）中所述一致，但是比（8）的功能简单多了。一个是32位数据的的二选一选择器，一个是5位数据的二选一选择器。

（10）dff32（32位寄存器）：

module dff32(d,clk,clrn,q);input [31:0] d;input     clk,clrn;output [31:0] q;reg  [31:0] q;always @ (negedge clrn or posedge clk)if (clrn == 0) begin q <= 0;end else beginq <= d;end
endmodule

普通32位寄存器的代码描述，当有清零信号来临时就清零，否则寄存器内就存入输入的32位数据q。

图四

（11）并行进位加法器（CLA）的实现：

module cla32 (a,b,ci,s,co);input   [31:0]  a,b;input  ci;output   [31:0]   s;output co;wire  g_out,p_out;cla_32  cla   (a,b, ci,g_out,p_out, s); assign  co  =  g_out| p_out &  ci;
endmodulemodule add(a,b,c,g,p,s);input a,b,c;output g,p,s;assign s = a^b^c;assign g = a & b;assign p = a | b;
endmodulemodule g_p  (g,p,c_in,g_out,p_out,c_out);
input  [1:0]  g,p;
input  c_in;
output g_out, p_out, c_out;
assign g_out = g[1]|p[1] & g[0];
assign p_out = p[1]  & p[0];
assign c_out = g[0]   |  p[0]  &  c_in;
endmodulemodule cla_2 (a,b,c_in,g_out,p_out,s) ;
input  [1:0]  a,b;
input c_in;
output g_out, p_out;
output  [1:0]  s;
wire  [1:0]  g,p;
wire c_out;
add add0 (a[0],b[0],c_in, g[0],p[0],s[0]);
add add1 (a[1],b[1],c_out, g[1],p[1],s[1]);
g_p g_p0 (g,p,c_in,  g_out,p_out,c_out);
endmodulemodule cla_4 (a,b, c_in,g_out,p_out,s);
input  [3:0]  a,b;
input  c_in;
output g_out, p_out;
output  [3:0]  s;
wire  [1:0]  g,p;
wire c_out;
cla_2 cla0 (a[1:0],b[1:0],c_in, g[0],p[0],s[1:0]);
cla_2 clal (a[3:2],b[3:2],c_out,g[1],p[1],s[3:2]);
g_p    g_p0  (g,p,c_in, g_out,p_out,c_out);
endmodulemodule  cla_8   (a,b, c_in,g_out,p_out, s);
input   [7:0]  a,b;
input  c_in;
output  g_out, p_out;
output   [7:0]   s;
wire   [1:0]   g,p;
wire  c_out;
cla_4  cla0  (a[3:0],b[3:0],c_in, g[0],p[0],s[3:0]);
cla_4  c1a1  (a[7:4],b[7:4],c_out,g[1],p[1],s[7:4]);
g_p   g_p0  (g,p,c_in,  g_out,p_out,c_out);
endmodulemodule cla_16 (a,b, c_in,g_out,p_out, s);
input   [15:0]  a,b;
input  c_in;
output  g_out, p_out;
output   [15:0]  s;
wire  [1:0]  g,p;
wire  c_out;
cla_8  cla0   (a[7:0],b[7:0],c_in,g[0],p[0],s[7:0]);
cla_8  cla1   (a[15:8],b[15:8],c_out,g[1],p[1],s[15:8]);
g_p    g_p0  (g,p,c_in,  g_out,p_out,c_out);
endmodulemodule cla_32  (a,b,c_in,g_out,p_out, s);
input  [31:0]  a,b;
input c_in;
output  g_out, p_out;
output  [31:0]  s;
wire  [1:0]  g,p;
wire c_out;
cla_16 c1a0 (a[15:0],b[15:0],c_in,g[0],p[0],s[15:0]);
cla_16 c1a1 (a[31:16],b[31:16],c_out,g[1],p[1],s[31:16]);
g_p    g_p0  (g,p,c_in, g_out,p_out,c_out);
endmodule

这段代码使用并行进位加法技术，从最基本的加法进位模型add实现全加器cla_2，逐步集成为4位全加器cla_4、8位的全加器cla_8、16位全加器cla_16、32位全加器cla_32（详见南京大学袁春风老师的《计算机组成与系统结构（第二版）》清华出版社P72），其实这段代码逐步集成为32位全加器的过程一看就知道是递归实现的，因为代码结构都是一样的。

（12）alu（运算逻辑单元）：

module alu (a,b,aluc,r,z);
input [31:0] a,b;    // aluc[3:0]
input [3:0] aluc;
output  [31:0]  r;   // x 0 0 0  ADD
output z;  // x1 0 0   SUB
wire  [31:0]  d_and = a & b;  // x 0 01   WD
wire  [31:0] d_or = a | b;    // x1 01   0R
wire  [31:0] d_xor = a ^ b;   // x 0 1 0   XOR
wire  [31:0]  d_lui = {b[15:0],16'h0};  // x1 1 0   LUI
wire  [31:0]  d_and_or = aluc[2]?d_or : d_and;  // 0 01 1   SLL,
wire  [31:0]  d_xor_1ui= aluc[2]?d_lui : d_xor; // 0 1 1 1   SRL
wire  [31:0]  d_as,d_sh;   // 1 1 1 1   SRA
addsub32 as32  (a,b,aluc[2],d_as);
shift shifter  (b,a[4:0],aluc[2],aluc[3],d_sh) ;
mux4x32 se1ect  (d_as,d_and_or, d_xor_1ui, d_sh, aluc[1:0],r);
assign z = ~|r;
endmodule

alu算术逻辑单元提供出来基础计算功能外的包括异或、按位与和按位或等逻辑计算功能。具体执行什么运算由4位aluc决定（最多能提供16种基础计算方式）。具体解释如下：

1）wire [31:0] d_and = a & b;这句代码提供按位与运算

2）wire [31:0] d_or = a | b;这句代码提供按位或运算

3）wire [31:0] d_xor = a ^ b;这句代码提供按位异或运算

4）wire [31:0] d_lui = {b[15:0],16'h0};高16位是所给数据b的低16位，低16位补0，两者拼接成32位数据

5）wire [31:0] d_and_or = aluc[2]?d_or : d_and;这句代码选择获取按位与还是按位或运算

6）wire [31:0] d_xor_1ui= aluc[2]?d_lui : d_xor; 这句代码与5）一致，目的在于选择运算结果

7）addsub32 as32(a,b,aluc[2],d_as);调用下面的（13）模块进行加或者减运算

8）shift shifter (b,a[4:0],aluc[2],aluc[3],d_sh) ;调用模块（1）进行左移或者右移

9）mux4x32 se1ect (d_as,d_and_or, d_xor_1ui, d_sh, aluc[1:0],r);四选一输出

（13）addsub32（32位加减运算模块）：

module addsub32(a,b,sub,s);input [31:0] a,b;input          sub;output [31:0] s;cla32 as32 (a,b^{32{sub}},sub,s);
endmodule

addsub32模块提供了32位数据的加或者减计算功能。具体是加还是减运算取决于sub的取值。

tz@COI HZAU

2018/7/10

转载于:https://www.cnblogs.com/acm-icpcer/p/9289857.html

Verilog HDL语言实现的单周期CPU设计（全部代码及其注释）相关推荐

31条指令单周期cpu设计(Verilog)-(十)上代码→顶层模块设计总结
说在前面开发环境:Vivado 语言:Verilog cpu框架:Mips 控制器:组合逻辑设计思路按照预先设计好的数据通路图将各个模块连接起来 `timescale 1ns / 1ps mod ...
31条指令单周期cpu设计(Verilog)-(二)总体设计
目录 31条指令单周期cpu设计(Verilog)-(一)相关软件 31条指令单周期cpu设计(Verilog)-(二)总体设计 31条指令单周期cpu设计(Verilog)-(三)指令分析 ...
(Verilog)单周期CPU设计
(Verilog)单周期CPU设计首先是基础资料部分(借用学校资料): 一.实验内容设计一个单周期CPU,该CPU至少能实现以下指令功能操作.需设计的指令与格式如下: ==> 算术运算指令 ...
合肥工业大学宣城校区计算机组成原理实验单周期 CPU 设计与实现
本实验使用的是Verilog,离谱的是CSDN居然找不到Verilog的代码块,只能使用c语言的代码块了. 一.实验目的: 通过设计并实现支持 10 条指令的CPU,进一步理解和掌握CPU 设计的基本 ...
Risc-V单周期CPU设计思考
Risc-V单周期CPU设计思考今年学校课程改革,计算机组成课开始教学Risc-V,写单周期CPU的时候发现网上好像大多都是MIPS的CPU设计,所以就把自己关于设计Verilog的一些思路整理出来 ...
单周期CPU设计与实现原理分析
文章目录单周期CPU设计与实现原理分析一.单周期CPU的设计思路二.单周期CPU的模块实现 ① Instruction Memory指令存储器的设计 ② ALU算术逻辑单元的设计 ③ PC程序计 ...
【Computer Organization笔记10】单周期CPU设计：基于7条MIPS指令的数据通路
本次笔记内容: P19 计算机组成原理(19) P20 计算机组成原理(20) 本节课对应幻灯片: 组成原理24 singlecycle.pptx 基于上节课的7条MIPS指令的数据通路,分别针对7条 ...
【中山大学计算机组成原理实验】单周期CPU设计与实现
实验一 : 单周期CPU设计与实现一. 实验目的 (1) 掌握单周期CPU数据通路图的构成.原理及其设计方法: (2) 掌握单周期CPU的实现方法,代码实现方法: (3) 认识和掌握指令与CPU的关 ...
计算机组成原理实验单周期处理,计算机组成原理实验实验报告-单周期cpu设计...
计算机组成原理实验实验报告-单周期cpu设计 (16页) 本资源提供全文预览,点击全文预览即可全文预览,如果喜欢文档就下载吧,查找使用更方便哦! 19.90 积分计算机组成原理实验计算机组成原理实验 ...

Verilog HDL语言实现的单周期CPU设计（全部代码及其注释）

Verilog HDL语言实现的单周期CPU设计（全部代码及其注释）相关推荐

最新文章

热门文章