单周期16位CPU模型机的设计与实现

2022-05-03 03:34:09

转载请标明文章出处，本文地址：https://www.hauhau.cn/article/a0caaef2.html#more

摘要

通过quartus软件，使用verilog语言，采用了结构化行为描述方法，完成了单周期CPU模型机的设计和仿真，实现了模型机的正常运行

关键字：整体、系统

第一章原理与模型机设计

1.1 实验有关原理

冯诺依曼计算机工作原理

计算机由控制器、运算器、存储器、输入设备、输出设备五大部分组成。
程序和数据以二进制代码形式不加区别地存放在存储器中，存放位置由地址确定。
控制器根据存放在存储器中地指令序列（程序）进行工作，并由一个程序计数器控制指令地执行。

单周期CPU：指的是一条指令的执行在一个时钟周期内完成，然后开始下一条指令的执行，即一条指令用一个时钟周期完成。
指令系统：指一台计算机的所有的指令合集。
指令周期：是从取指令、分析指令到执行完该指令所需的时间，不同的指令其指令周期长短可以不同。
单周期CPU处理指令的步骤：
取指令 -> 指令译码 -> 指令执行 -> 存储器访问 -> 结果写回

1.2 模型机设计

结构框图

控制线路图

对应模块及功能

InstructionMemory：指令存储器，依据输入的地址从存储器中取出相对应的指令。

CU：控制单元，对指令进行分析，确定应该进行什么操作，并按照确定的时序向相应的部件发出控制信号。

Register：数据寄存器(图1.2.4)，负责将alu的运算数据和存储器中取出和存入的数据进行暂存，起到缓存的作用，因为单周期内不能同时读写，所以加入了一级缓存的设计。

ALU：算术逻辑单元(图1.2.5)，依据输入的操作码和数据进行相应的算数运算和逻辑运算。

memRam：数据存储器(图1.2.6)，对数据进行存储

PC：程序计数器，进行取值操作，完成第一条指令的执行，而后根据PC取出第二条指令的地址。PC中的地址自动加一或由转移指令给出下一条指令的地址。

第二章原理与模型机设计

2.1操作码格式

本次实验采用的是定长编码，机器指令16位编码，故根据实际需求设计出以下操作码：

`define ADD 4'b0000 //算术加
`define INC 4'b0001 //算术加1
`define NOT 4'b0010 //逻辑非
`define AND 4'b0011 //逻辑与
`define OR 4'b0100 //逻辑或
`define SLF 4'b0101 //数据左移
`define SRF 4'b0110 //数据右位
`define JMP 4'b0111 //无条件转移
`define STO 4'b1000 //写存储器，存数
`define LAD 4'b1001 //读存储器，取数
`define MOV 4'b1010 //数据传送
`define HAT 4'b1111 //暂停

2.2指令与格式

==\>算数运算指令

(1) ADD rd, rs, rt

0000	rd(四位)	rs(四位)	rt(四位)

功能：rd <- rs + rt (算数加)

(2) INC rt, rs

0001	rt(四位)	rs(四位)	0000(未用)

功能：rt <- rs (算数加1)

==\>逻辑运算指令

(3) NOT rt, rs

0010	rt(四位)	rs(四位)	0000(未用)

功能：rt <- !rs (逻辑非运算)

(4) AND rd, rs, rt

0011	rd(四位)	rs(四位)	rt(四位)

功能：rd <- rs & rt (逻辑与运算)

(5) OR rd, rs, rt

0100	rd(四位)	rs(四位)	rt(四位)

功能：rd <- rs | rt (逻辑或运算)

==\>移位指令

(6) SLF rd, rs, rt

0101	rd(四位)	rs(四位)	rt(四位)

功能：rd <- rs\<\<rt (左移)

(7) SRF rd, rt, rs

0110	rd(四位)	rs(四位)	rt(四位)

功能：rd <- rs\>\>rt (右移)

==\>存储器读写指令

(8) STO rt, rs

1000	rt(三位)	0(未用)	rs(四位)	0000(未用)

功能：将数据从寄存器写入到数据存储器

(9) LAD rt, rs

1001	rt(四位)	rs(三位)	00000(未用)

功能：将数据从数据存储器读出到寄存器

==\>无条件转移指令

(10) JMP

0111	0000(未用)	转移指令地址(八位)

功能：跳转到指定的指令地址

==\>停机指令

(11) HLT

1111	000000000000(未用)

功能：停机，PC的值保持不变

第三章模型机实现与测试

3.1Verilog程序设计

headfile.v：

`ifndef HEADFILE_H_

`define ADD 4'b0000 //算术加
`define INC 4'b0001 //算术加1
`define NOT 4'b0010 //逻辑非
`define AND 4'b0011 //逻辑与
`define OR  4'b0100 //逻辑或
`define SLF 4'b0101 //数据左移
`define SRF 4'b0110 //数据右位
`define JMP 4'b0111 //无条件转移
`define STO 4'b1000 //写存储器，存数
`define LAD 4'b1001 //读存储器，取数
`define MOV 4'b1010 //数据传送
`define HAT 4'b1111 //暂停

`define rg0 4'b0000 //寄存器0
`define rg1 4'b0001 //寄存器1
`define rg2 4'b0010 //寄存器2

`endif

alu.v:

`timescale 1ns / 1ps
`include "headfile.v"

//ALU，进行逻辑运算和算数运算
module alu(op, a, b, n, f);
    input [3:0] op, n;
    input [7:0] a, b;
    output [7:0] f;
    reg [7:0] f;
    
    always@(*)
    begin
        case(op)
            `ADD:   f = a + b;
            `INC:   f = a + 1;
            `NOT:   f = ~a;
            `AND:   f = a&b;
            `OR:    f = a|b;
            `SLF:   f = a<<n;
            `SRF:   f = a>>n;
            default:    f = 8'b00000000;
        endcase
    end
    
endmodule

memRam.v：

`timescale 1ns / 1ps
`include "headfile.v"

//存储器
module memRam(data,wren,address,inclock,outclock,q);
    
    parameter wordsize = 8;
    parameter memsize = 8;
    parameter addr = 3; //3位地址线
    
    input [wordsize-1:0] data;
    input [addr-1:0] address;
    input wren,inclock,outclock;
    output [wordsize-1:0] q;
    reg [wordsize-1:0] q;
    reg [wordsize-1:0] ram [memsize-1:0];
    
    integer i;
    
    initial 
        begin//初始化
            for(i=0; i<8; i=i+1)
                ram[i]=8'b00000000;
            ram[0]=8'b00000010; //在第0位写入2
            
        end
    
    always@(posedge inclock)    //inclock上升沿触发
        begin
            if(~wren)
                ram[address] = data;    //wren为低电平时，将data写入到对应地址
        end
    
    always@(posedge outclock)   //outclock上升沿触发
        begin
            if(wren)
                q = ram[address];   //wren为高电平时，读出对应地址的数据
        end
        
endmodule

Register.v：

`timescale 1ns / 1ps
`include "headfile.v"

//寄存器
module Register(clk,data,wren,inaddr,outaddr1,outaddr2,
                    regtoalu1,regtoalu2,regtomemaddr,regtomem,
                    memtoregwren,memtoregaddr,memtoregdata);
    
    input [7:0] data;
    input [3:0] inaddr,outaddr1,outaddr2,regtomemaddr,memtoregaddr;
    input wren,clk,memtoregwren;
    output [7:0] regtoalu1,regtoalu2,regtomem,memtoregdata;
    
    reg [7:0] regmem [15:0];
    
    reg lwren,lmemtoregwren;
    reg [3:0] linaddr,lmemtoregaddr;
    reg [7:0] ldata,lmemtoregdata;
    
    integer i;
    
    initial 
        begin//初始化
            lwren = 1'b0;
            lmemtoregwren = 1'b0;
            for(i=0; i<16; i=i+1)
                regmem[i]=8'b00000000;
        end
        
    always@(posedge clk)    //缓存
        begin
            lwren <= wren;
            linaddr <= inaddr;
            ldata <= data;
            
            lmemtoregwren <= memtoregwren;
            lmemtoregaddr <= memtoregaddr;
            lmemtoregdata <= memtoregdata;
        end
    
    always@(*)
        begin
            if(lwren)
                regmem[linaddr] <= ldata;   //将data写入到对应地址
            if(lmemtoregwren)
                regmem[lmemtoregaddr] <= lmemtoregdata;
        end
        
    assign regtoalu1 = regmem[outaddr1];    //从寄存器取值
    assign regtoalu2 = regmem[outaddr2];
    assign regtomem = regmem[regtomemaddr];
        
endmodule

InstructionMemory.v：

`timescale 1ns / 1ps
`include "headfile.v"

//存储指令
module InstructionMemory(A, RD);

    input [7:0] A;
    output [15:0] RD;
    
    reg [15:0] IM [29:0];
    assign RD = IM[A];//立即根据地址取出内容
    
    //执行成功后，存储器中从1到7位的数据应为：2，3，5，2，3，253，250，126
    initial begin
        IM[0] = {`LAD, `rg0, 3'b000, 5'b00000};     //从存储器第0位读取数据到寄存器rg0，rg0 = 2

/*-----------------------------------------------------------------*/
        IM[1] = {`INC, `rg1, `rg0, 4'b0000};            //将寄存器rg0的数据算术加1并将结果移到rg1，rg1 = rg0 + 1 = 2 + 1 = 3

        IM[2] = {`STO, 3'b001, 1'b0, `rg1, 4'b0000};    //将寄存器rg1中的数据存入存储器第1位，3
/*-----------------------------------------------------------------*/
        IM[3] = {`ADD, `rg2, `rg1, `rg0}; //将寄存器rg0和rg1中的数相加并将结果存入rg2，rg2=rg0+rg1=2+3=5

        IM[4] = {`STO, 3'b010, 1'b0, `rg2, 4'b0000};    //将寄存器rg2中的数据存入存储器第2位,5
/*-----------------------------------------------------------------*/
        IM[5] = {`JMP, 4'b0000, 8'b00000111};   //跳转到第七条指令
        IM[6] = {`HAT, 12'b000000000000};   //若没有跳转成功，就会停机
/*-----------------------------------------------------------------*/
        IM[7] = {`AND, `rg2, `rg1, `rg0}; //将寄存器rg0和rg1中的数进行与运算并存入rg2，rg2 = rg1 & rg0 = 00000011 & 00000010 = 00000010（2）

        IM[8] = {`STO, 3'b011, 1'b0, `rg2, 4'b0000};    //将寄存器rg2中的数据存入存储器第3位，2
/*-----------------------------------------------------------------*/
        IM[9] = {`OR, `rg2, `rg1, `rg0}; //将寄存器rg0和rg1中的数进行或运算并存入rg2，/rg2 = rg1 | rg0 = 00000011 | 00000010 = 00000011（3）

        IM[10] = {`STO, 3'b100, 1'b0, `rg2, 4'b0000};   //将寄存器rg2中的数据存入存储器第4位，3
/*-----------------------------------------------------------------*/
        IM[11] = {`NOT, `rg2, `rg0, 4'b0000};           //将寄存器rg0的数据进行非运算并将结果存入rg2，rg2 = ~rg0 = ~00000010 = 11111101（253）

        IM[12] = {`STO, 3'b101, 1'b0, `rg2, 4'b0000};   //将寄存器rg2中的数据存入存储器第5位，253
/*-----------------------------------------------------------------*/
        IM[13] = {`SLF, `rg0, `rg2, 4'b0001}; //rg2的数据左移一位并将结果存入rg0，rg0 = rg2<<1 = 11111101<<1 = 11111010（250）

        IM[14] = {`STO, 3'b110, 1'b0, `rg0, 4'b0000};   //将寄存器rg0中的数据存入存储器第6位，250
/*-----------------------------------------------------------------*/
        IM[15] = {`SRF, `rg1, `rg2, 4'b0001}; //rg2的数据右移一位并将结果存入rg1，rg1 = rg2>>1 = 11111101>>1 = 01111110（126）

        IM[16] = {`STO, 3'b111, 1'b0, `rg1, 4'b0000};   //将寄存器rg2中的数据存入存储器第7位，126
/*-----------------------------------------------------------------*/
        IM[17] = {`HAT, 12'b000000000000}; //停机
        IM[18] = 16'b0000000000000000;
        IM[19] = 16'b0000000000000000;
        IM[20] = 16'b0000000000000000;
        IM[21] = 16'b0000000000000000;
        IM[22] = 16'b0000000000000000;
        IM[23] = 16'b0000000000000000;
        IM[24] = 16'b0000000000000000;
        IM[25] = 16'b0000000000000000;
        IM[26] = 16'b0000000000000000;
        IM[27] = 16'b0000000000000000;
        IM[28] = 16'b0000000000000000;
        IM[29] = 16'b0000000000000000;
    end

endmodule

CU.v：

`timescale 1ns / 1ps
`include "headfile.v"

//控制不同指令下对数据的分发

module CU(
    input [15:0] instr,
    output enable,
    output reg [3:0] regoutaddr1,
    output reg [3:0] regoutaddr2,
    output reg [3:0] reginaddr,
    output reg [3:0] regtomemaddr,
    output reg [3:0] memtoregaddr,
    output reg [3:0] aluop,
    output reg [3:0] alun,
    output reg memwren,
    output reg memtoregwren,
    output reg [2:0] memaddr,
    output reg [7:0] pcnextaddr,
    output reg pcnext,
    output reg pcflag,
    output reg regwren);
    
wire [3:0] op;
assign op = instr[15:12];

initial
    begin
        regwren = 1'b0;
        memtoregwren <= 1'b0;
        memwren = 1'b1;
        pcnext = 1'b0;
        pcflag = 1'b0;
    end

always@(*)
    begin
        if((op == `ADD)||(op == `AND)||(op == `OR))
            begin
                aluop <= instr[15:12];
                regoutaddr1 <= instr[3:0];
                regoutaddr2 <= instr[7:4];
                regwren <= 1'b1;
                reginaddr <= instr[11:8];
            end
        else if((op == `SLF)||(op == `SRF))
            begin
                aluop <= instr[15:12];
                alun <= instr[3:0];
                regoutaddr1 <= instr[7:4];
                regwren <= 1'b1;
                reginaddr <= instr[11:8];
            end
        else if((op == `INC)||(op == `NOT))
            begin
                aluop <= instr[15:12];
                regoutaddr1 <= instr[7:4];
                regwren <= 1'b1;
                reginaddr <= instr[11:8];
            end
        else if((op == `STO))
            begin
                    regtomemaddr <= instr[7:4];
                        memaddr <= instr[11:9];
                        memwren <= 1'b0;
            end
        else if((op == `LAD))
            begin
                memaddr <= instr[7:5];
                memwren <= 1'b1;
                memtoregaddr <= instr[11:8];
                memtoregwren <= 1'b1;
            end
        else
            begin
                regwren <= 1'b0;
                memtoregwren <= 1'b0;
                //memwren <= 1'b1;
            end
    end
    
always@(*)
    begin
        if((op == `JMP))
            begin
                pcnextaddr <= instr[7:0];
                pcnext <= 1'b1;
                pcflag <= 1'b1;
            end
        else
            pcnext <= 1'b0;
    end

    
    assign enable = ~(op == `HAT);
endmodule

CPU_top.v：

`timescale 1ns / 1ps

//顶层模块，用于连接各模块
module CPU_top(
    input clk,
    input reset,
    output [7:0] OPT_PC
    );
    
    reg [7:0] PC;
    wire [15:0] instr;
    wire [7:0] aluout;
    wire [3:0] alun;
    wire [3:0] aluop;
    wire regwren,enable,memwren,memtoregwren,pcnext,pcflag;
    wire [2:0] memaddr;
    wire [3:0] memtoregaddr;
    wire [3:0] Reginaddr;
    wire [3:0] Regoutaddr1;
    wire [3:0] Regoutaddr2;
    wire [3:0] regtomemaddr;
    wire [7:0] Registerout1;
    wire [7:0] Registerout2;
    wire [7:0] memtoregdata;
    wire [7:0] regtomem;
    wire [7:0] NextPC;
    wire [7:0] pcnextaddr;
    
    initial begin
        PC = 8'b00000000;
    end
    
    InstructionMemory IM(
        .A(PC),
        .RD(instr)
    );
    
    CU m0(
        .instr(instr),
        .enable(enable),
        .regoutaddr1(Regoutaddr1),
        .regoutaddr2(Regoutaddr2),
        .reginaddr(Reginaddr),
        .regtomemaddr(regtomemaddr),
        .memtoregaddr(memtoregaddr),
        .aluop(aluop),
        .alun(alun),
        .memwren(memwren),
        .memtoregwren(memtoregwren),
        .memaddr(memaddr),
        .pcnextaddr(pcnextaddr),
        .pcnext(pcnext),
        .pcflag(pcflag),
        .regwren(regwren)
   );
    
    Register R(
        .clk(clk),
        .data(aluout),
        .wren(regwren),
        .inaddr(Reginaddr),
        .outaddr1(Regoutaddr1),
        .outaddr2(Regoutaddr2),
        .regtoalu1(Registerout1),
        .regtoalu2(Registerout2),
        .regtomemaddr(regtomemaddr),
        .regtomem(regtomem),
        .memtoregwren(memtoregwren),
        .memtoregaddr(memtoregaddr),
        .memtoregdata(memtoregdata)
   );
    
    
    alu A(
        .op(aluop),
        .a(Registerout1),
        .b(Registerout2),
        .n(alun),
        .f(aluout)
   );
    
    memRam M(
        .data(regtomem),
        .wren(memwren),
        .address(memaddr),
        .inclock(clk),
        .outclock(clk),
        .q(memtoregdata)
   );
    
    
    assign NextPC = (pcnext) ? pcnextaddr : (PC + 1'b1);    //判定是跳转到指定地址还是执行下一条指令
    
    always@(posedge clk)    //时序，每个周期PC值变化一次
    begin
        if(reset)
            PC <= 0;
        else
            begin
                if(enable)
                    PC <= NextPC;
                else
                    PC <= PC; //停机指令，PC值保持不变
            end
    end

    assign OPT_PC = PC;
    
endmodule

3.2测试程序

CPU_test.v：

`timescale 1ns / 1ps

module CPU_test(OPT_PC);
    
    output [7:0] OPT_PC;
    reg clk;
    reg reset;
    
    
    CPU_top uut(
        .clk(clk),
        .reset(reset),
        .OPT_PC(OPT_PC)
    );
    
    
    //执行成功后，存储器中从1到7位的数据应为：2，3，5，2，3，253，250，126
    initial begin
        clk = 0;
        reset = 1;  //初始化CPU
        
        #100;
        
        reset = 0;
        
        $display(" pc:     instr      :  ALUR  :rg0:rg1:rg2: m0: m1: m2: m3: m4: m5: m6: m7");
        $monitor("%d:%b:%b:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d", 
            uut.PC, uut.instr, uut.aluout, uut.R.regmem[0], uut.R.regmem[1], uut.R.regmem[2], 
            uut.M.ram[0], uut.M.ram[1], uut.M.ram[2], uut.M.ram[3], 
            uut.M.ram[4], uut.M.ram[5], uut.M.ram[6], uut.M.ram[7] );
      
        #2000 $stop;
    end
    
    always #50 clk = ~clk;
      
endmodule

3.3模型机执行程序的过程的分析

仿真得到的波形图

控制台输出

指令的分析

指令0：从存储器第0位读取数据到寄存器rg0，rg0=2，存储器第0位为2
指令1：将寄存器rg0的数据算术加1并将结果移到rg1，rg1 = rg0+1=2+1=3
指令2：将寄存器rg1中的数据存入存储器第1位，存储器第1位为3
指令3：将寄存器rg0和rg1中的数相加并将结果存入rg2，rg2=rg0+rg1=2+3=5
指令4：将寄存器rg2中的数据存入存储器第2位, 存储器第2位为5
指令5：跳转到第七条指令
指令6：若没有跳转成功，就会停机
指令7：将寄存器rg0和rg1中的数进行与运算并存入rg2，rg2=00000011&00000010=00000010
指令8：将寄存器rg2中的数据存入存储器第3位，存储器第3位为2
指令9：将寄存器rg0和rg1中的数进行或运算并存入rg2，rg2=
00000011|00000010=00000011
指令10：将寄存器rg2中的数据存入存储器第4位，存储器第4位为3
指令11：将寄存器rg0的数据进行非运算并将结果存入rg2，rg2=\~00000010=11111101（253）
指令12：将寄存器rg2中的数据存入存储器第5位，存储器第5位为253
指令13：rg2的数据左移一位并将结果存入rg0，rg0=rg2\<\<1=11111101\<\<1=11111010（250）
指令14：将寄存器rg0中的数据存入存储器第6位，存储器第6位为250
指令15：rg2的数据右移一位并将结果存入rg1，rg1=rg2\>\>1=11111101\>\>1=01111110（126）
指令16：将寄存器rg2中的数据存入存储器第7位，存储器第7位为126
指令17：停机

结果分析

指令0-2：测试算数加一，计算2+1=3，得到3存储在存储器第1位上
指令3-4：测试加法，计算2+3=5，得到5存储在存储器第2位上
指令5-6，测试跳转指令
指令7-8，测试与运算，计算00000011 & 00000010，得到3存储在存储器第2位上
指令9-10，测试或运算，计算00000011 | 00000010，得到4存储在存储器第3位上
指令11-12，测试非运算，计算\~00000010，得到253存储在存储器第5位上
指令13-14，测试左移，11111101\<\<1，得到250存储在存储器第6位上
指令15-16，测试右移，11111101\>\>1，得到126存储在存储器第7位上

从波形图(图3.3.1)中可以看到从指令5跳转到指令7，跳转指令成功运行，而指令17后每个周期PC的值都不变。

从控制台的输出(图3.3.2)中可以看到存储器中的数值为：2，3，5，2，3，253，250，126和对指令的分析是一致的。

参考文献

https://www.cnblogs.com/wsine/p/4655943.html

https://blog.csdn.net/linwh8/article/details/71308282

码农公寓

第一章 原理与模型机设计