代码中理解CPU结构及工作原理

一、前言

　　从研究生开始到工作半年，陆续在接触MCU SOC这些以CPU为核心的控制器，但由于专业的原因一直对CPU的内部结构和工作原理一知半解。今天从一篇博客中打破一直以来的盲区。特此声明，本文设计思想及代码均源于如下博文，这里仅用于自己学习记录，以及分享心得之用。

简易CPU的设计和实现_阡飞陌-CSDN博客
https://blog.csdn.net/weixin_36077867/article/details/82286612

二、简易CPU结构与工作原理概述

       用下原文中的结构图：

 　　CPU核心模块包括控制器、程序计数器（PC）、存储器（memory）、译码器和算术逻辑单元（ALU）。控制器负责指挥调度各个模块正常工作：PC每到达一个数阶段内，均会进行取指令->译码->执行指令。取指令从memory中取出PC值指向地址的数据，之后数据传入译码器翻译为具体操作目的，最后根据这一目标来让ALU完成算数和逻辑运算，并将运算结果保存到memory指定地址。memory的内容就是在我们之前玩单片机时用IDE将C/C++等高级语言转化成的比特流，里边包括了代码指令、临时变量及所有需要保存的数据数值。

三、设计代码与仿真分析

　　以下代码仅是对转载博客中进行了少许改动，并无实质变化。

`timescale 1ns / 1ps

// Description: 
// program counter 

module PC
#(parameter ADDR_WIDTH = 5)
(
input clock,
input reset,
input en,
output reg [ADDR_WIDTH-1:0] pc 
    );
    
    wire [ADDR_WIDTH-1:0] pc_next;
    
    always@(posedge clock or posedge reset)begin
        if(reset)
            pc <= 0;
        else if(en)
            pc <= pc_next;
    end
    
    assign pc_next = pc + 1;
    
endmodule

`timescale 1ns / 1ps

// Description: 
// memory used for storing instructions, temporary variables, and initialization data
//STA，store A to
//LDA, load A from


module memory
#(
parameter ADDR_WIDTH = 5,
parameter DATA_WIDTH = 8
)
(
input clock,
input reset,
input wr_en,
input rd_en,
input [ADDR_WIDTH-1:0] addr,
input [DATA_WIDTH-1:0] din,
output reg [DATA_WIDTH-1:0] dout
    );
    
    reg [DATA_WIDTH-1:0] mem [0:32-1];
    
    always@(posedge clock,posedge reset)begin
        if(reset)begin
            mem [0] <= 'b000_01011;      //LDA 01011
            mem [1] <= 'b010_01100;      //ADD 01100
            mem [2] <= 'b001_01101;      //STA 01101
            mem [3] <= 'b000_01011;      //LDA 01011
            mem [4] <= 'b100_01100;      //AND 01100
            mem [5] <= 'b001_01110;      //STA 01110
            mem [6] <= 'b000_01011;      //LDA 01011
            mem [7] <= 'b011_01100;      //SUB 01100
            mem [8] <= 'b001_01111;      //STA 01111
            mem [9] <= 'b10100000;      //HLT
            mem [10] <= 'b00000000;
            mem [11] <= 'b10010101;
            mem [12] <= 'b01100101;
            mem [13] <= 'b00000000;
            mem [14] <= 'b00000000;
            mem [15] <= 'b00000000;
            mem [16] <= 'b00000000;
            mem [17] <= 'b00000000;
            mem [18] <= 'b00000000;
            mem [19] <= 'b00000000;
            mem [20] <= 'b00000000;
            mem [21] <= 'b00000000;
            mem [22] <= 'b00000000;
            mem [23] <= 'b00000000;
            mem [24] <= 'b00000000;
            mem [25] <= 'b00000000;
            mem [26] <= 'b00000000;
            mem [27] <= 'b00000000;
            mem [28] <= 'b00000000;
            mem [29] <= 'b00000000;
            mem [30] <= 'b00000000;
            mem [31] <= 'b00000000;
        end
        else begin
            if(wr_en)
                mem[addr] <= din;
            else if(rd_en)
                dout <= mem[addr];
        end
    end
endmodule

`timescale 1ns / 1ps

// Description: 
// instruction decoder


module idec
#(
parameter DATA_WIDTH = 8,
parameter ADDR_WIDTH = 5
)
(
input clock,
input reset,
input en,
input [DATA_WIDTH-1:0] instruction,//from memory
output reg [DATA_WIDTH-ADDR_WIDTH-1:0] opcode,
output reg [ADDR_WIDTH-1:0] addr
    );
    
    always@(posedge clock,posedge reset)begin
        if(reset)begin
            opcode <= 0;
            addr <= 0;
        end
        else if(en)begin
            opcode <= instruction[DATA_WIDTH-1 -:3];
            addr <= instruction[ADDR_WIDTH-1:0];
        end
    end
    
endmodule

`timescale 1ns / 1ps

// Description: 
// arithmetic logic unit


module alu 
#(parameter OP_WIDTH = 8)
(
input clock,
input reset,

input en,
input add_en,//加法运算使能
input sub_en,
input and_en,
input pass_en,
input [OP_WIDTH-1:0] din,

output n,//负标志
output z,//0标志
output reg c,//输出进位标志
output v,//输出溢出标志
output reg [OP_WIDTH-1:0] a//累加器输出寄存器 dout

    );
    
    assign n = (c == 1) ? 1: 0 ;       //负数标志，如果进位标志为1,则n=1                                    
    assign z = (a == 'd0) ? 1: 0 ;    //0标志，如果累加器为0，z=1                                        
    assign v = ((a>2**(OP_WIDTH-1)-1) || (a<-2**(OP_WIDTH-1)) ? 1:0 );  //溢出标志  补码取值范围：-2^(n-1)~~~~~2^(n-1)-1   n=8              
                                                                  
    always @(posedge clock or posedge reset)begin 
        if (reset) begin
            a <= 0;      //复位累加器清0，
            c <= 0;    
        end
        else begin
            if(en) begin
                if(add_en)
                    {c,a} <= a + din;
                else if(sub_en)
                    {c,a} <= a - din;
                else if(and_en)
                    a <= a & din;
                else if(pass_en)
                    a <= din; 
            end
        end
    end    
 
endmodule

`timescale 1ns / 1ps


module control#(
parameter DATA_WIDTH = 8,
parameter ADDR_WIDTH = 5
)
(
input clock,
input reset,
input [DATA_WIDTH-ADDR_WIDTH-1:0] opcode,//来自解码器解码后指令

output reg [6-1:0] s,//使能信号
output reg addr_sel,//程序或数据地址选通
output reg [4-1:0] instrs

);

    parameter [DATA_WIDTH-ADDR_WIDTH-1:0] LDA = 'b000,
                                          STA = 'b001,
                                          ADD = 'b010,
                                          SUB = 'b011,
                                          AND = 'b100;
    
    reg [8-1:0] cnt;
    wire add_cnt,end_cnt;
    
    always@(posedge clock, posedge reset)begin
        if(reset)
            cnt <= 0;
        else if(add_cnt)begin
            if(end_cnt)
                cnt <= 0;
            else 
                cnt <= cnt + 1;
        end
    end
    
    assign add_cnt = 1;
    assign end_cnt = add_cnt && cnt == 6-1;
    
    always@(*)begin
        case(cnt)
            0:begin//取指令
                 s = 'b100_000;
                 addr_sel = 0; 
                 instrs = 0;
            end
            1:begin//解码
                s = 'b010_000;
                addr_sel = 0;
            end
            2:begin//read from the memory
                addr_sel = 1;
                if(
                   (opcode == LDA) ||
                   (opcode == ADD) ||
                   (opcode == SUB) ||
                   (opcode == AND)
                   )
                    s = 'b001_000;
                else
                    s = 'b000_000;
            end
            3:begin//ALU operations
                s = 'b000_100;
                addr_sel = 1;
                case(opcode)
                    LDA:instrs = 'b0001;
                    ADD:instrs = 'b1000;
                    SUB:instrs = 'b0100;
                    AND:instrs = 'b0010;
                    STA:instrs = 'b0000;
                    default:instrs = 'b0000;
                endcase
            end
            4:begin//write to the memory
                addr_sel = 1;
                if(opcode == STA)
                    s = 'b000_010;
                else
                    s = 'b000_000;
            end
            5:begin// PC 
                s = 'b000_001;
                addr_sel = 1;
            end
            default:begin
                s = 'b000_000;
                addr_sel = 0;
                instrs = 0;
            end
        endcase
    end

endmodule

`timescale 1ns / 1ps

module cpu_top
(
input clock,
input reset,

output n,//负标志
output z,//0标志
output c,//输出进位标志
output v//输出溢出标志
);

parameter DATA_WIDTH = 8,
          ADDR_WIDTH = 5;
            

wire [6-1:0] s;
wire [ADDR_WIDTH-1:0] addr_mem,addr_idec,addr_pc;
wire addr_sel;
wire [DATA_WIDTH-1:0] dout_mem,din_mem;
wire [DATA_WIDTH-ADDR_WIDTH-1:0] opcode;
wire [4-1:0] alu_oper;

assign addr_mem = addr_sel == 1 ?  addr_idec: addr_pc; 

control#(
.DATA_WIDTH (DATA_WIDTH),
.ADDR_WIDTH (ADDR_WIDTH)
)
controlor
(
    .clock        (clock),
    .reset        (reset),
    .opcode        (opcode),//来自解码器解码后指令
    .s            (s),//使能信号
    .addr_sel    (addr_sel),//程序或数据地址选通
    .instrs        (alu_oper)

);

PC 
#(.ADDR_WIDTH (ADDR_WIDTH))
pointer_counter
(
    .clock    (clock),
    .reset    (reset),
    .en        (s[0]),
    .pc     (addr_pc)//code address    
    );
    
    
memory 
#(
.ADDR_WIDTH(ADDR_WIDTH),
.DATA_WIDTH (DATA_WIDTH)
)
memory
(
    .clock    (clock),
    .reset    (reset),
    .wr_en    (s[1]),
    .rd_en    (s[5] | s[3]),
    .addr    (addr_mem),
    .din    (din_mem),
    .dout    (dout_mem)
    );

idec 
#(
.DATA_WIDTH (DATA_WIDTH),
.ADDR_WIDTH (ADDR_WIDTH)
)
instr_decoder
(
    .clock        (clock),
    .reset        (reset),
    .en            (s[4]),
    .instruction(dout_mem),//from memory
    
    .opcode        (opcode),
    .addr        (addr_idec)//data address
    );
    
alu 
#(.OP_WIDTH(DATA_WIDTH))
alu
(
    .clock        (clock),    
    .reset        (reset),
    .en            (s[2]),
    .add_en        (alu_oper[3]),//加法运算使能
    .sub_en        (alu_oper[2]),
    .and_en        (alu_oper[1]),
    .pass_en    (alu_oper[0]),
    .din        (dout_mem),    
    .n            (n),//负标志
    .z            (z),//0标志
    .c            (c),//输出进位标志
    .v            (v),//输出溢出标志
    .a            (din_mem)//累加器输出寄存器 dout

    );
    

endmodule

 　　现在仿真观察逻辑是否按照预期工作。这里使用Questasim工具，该工具的Windows/Linux版本都很容易下载到，而且对SV UVM支持程度高，是芯片自学的首选。只写了个简单的testbench来toggle clock和reset。

`timescale 1ns/1ps;

module tb_top;

    parameter T = 10;

    logic clock;
    logic reset;
    logic n,z,c,v;

    initial begin:clock_toggle
        clock = 1;
        forever begin
            #(T/2.0);
            clock = ~clock;
        end
    end
    
    initial begin
        reset = 0;
        #1;
        reset = 1;
        #T;
        reset = 0;
        #20;
        $stop;
    end
    
cpu_top DUT
(
.clock    (clock),
.reset    (reset),
.n        (n),//负标志
.z        (z),//0标志
.c        (c),//输出进位标志
.v        (v)//输出溢出标志
);

endmodule

 　　PC不断从0计数到5.每个计数周期内，各个模块的使能信号s也在交替拉高，指示当前进行不同的操作步骤。我们以第三个周期为例：

 　　s5：读取memory的'h1地址数据'b010_01100

　　s4:得到8'h4c，解析出当前操作码是高三位3'h2(ADD)，操作地址是第五位5'h0c

　　s3:读取5'h0c地址内的数据'b0110_0101 即8'h65

　　s2:调用ALU，将上次计算结果与当前读取memory中数据相加给din_mem。'h95+'h65='hfa

　　s1:由于操作码不包括写入，当前时钟不操作

　　s0:PC加1，为下一个指令周期做准备

　　这个“CPU”真的简单到几乎不能做任何事情，但其对于初步接触的人还是很有帮助的。现代CPU指令集非常庞大，还包括一些寄存器、总线单元等专用硬件逻辑，所以要学的还有很多。从应用角度来讲，在更上一个层次掌握MCU的结构及原理更加重要。