2024-10-28

NAND2Tetris:带你从零开始手搓计算机之项目3——搭建RAM：内存

总述

在前面两个项目中，我们构建的布尔芯片(最基本的逻辑门)和算术芯片(ALU)本质上都是组合芯片,即用组合逻辑电路实现的,这些芯片可以通过逻辑运算来实现对应的逻辑功能,但是它们却不能维持自身的状态。计算机不能仅仅只能计算值,还需要存储数据,这些芯片需要配备记忆单元来保存数据,这些记忆单元就是由时序芯片来组成的。

在本个项目中,我们将通过一个简单的D触发器,来一步步构建一个一位寄存器、十六位的寄存器、再通过寄存器来构建大的随机存储内存单元,也就是RAM(Random access memory),在RAM上,我们可以随机访问被选择的字,而不会受限访问顺序(这要求我们查找存储地址)。这个项目的重点和难点在于在满足电路逻辑功能的基础上,我们添加了时钟这一增量,如何在我们的HDL代码中体现时钟的作用,就需要我们进一步深入的思考。

在这个项目中,我们会构建一个由8个寄存器堆叠的RAM8,然后进一步构建一个64个存储器堆叠的RAM64,然后到RAM512、RAM4K、RAM16K,这里涉及到一个分层设计的思想,拾级而上,对我们解决大型的项目有帮助。

Bit——一位的寄存器

/**
 * 1-bit register:
 * If load is asserted, the register's value is set to in;
 * Otherwise, the register maintains its current value:
 * if (load(t)) out(t+1) = in(t), else out(t+1) = out(t)
 */
CHIP Bit {
    IN in, load;
    OUT out;

    PARTS:
    Mux(a=dffOut, b=in, sel=load, out=muxOut);
    DFF(in=muxOut, out=dffOut);
    Or(a=false, b=dffOut, out=out); 
}

dffOut是D触发器在时钟触发的输出,我们用一个Mux选择器,来实现对D触发器输入的更改。

当load=0的时候,muxOut = dffOut,也就是说不管我的in如何修改,我们都不会存储这个数据,下一次的输出还是和上一次保持一样,当load=1的时候,muxOut = in,也就是存储功能开启,存储器会保存这个输入数据到输出。

最后一个Or门其实就是让out=dffOut,因为在我们的语法中,不允许out作为另外门的输入。

Register

/**
 * 16-bit register:
 * If load is asserted, the register's value is set to in;
 * Otherwise, the register maintains its current value:
 * if (load(t)) out(t+1) = int(t), else out(t+1) = out(t)
 */
CHIP Register {
    IN in[16], load;
    OUT out[16];

    PARTS:
    Bit(in=in[0] , load=load , out=out[0]);
    Bit(in=in[1] , load=load , out=out[1]);
    Bit(in=in[2] , load=load , out=out[2]);
    Bit(in=in[3] , load=load , out=out[3]);
    Bit(in=in[4] , load=load , out=out[4]);
    Bit(in=in[5] , load=load , out=out[5]);
    Bit(in=in[6] , load=load , out=out[6]);
    Bit(in=in[7] , load=load , out=out[7]);
    Bit(in=in[8] , load=load , out=out[8]);
    Bit(in=in[9] , load=load , out=out[9]);
    Bit(in=in[10] , load=load , out=out[10]);
    Bit(in=in[11] , load=load , out=out[11]);
    Bit(in=in[12] , load=load , out=out[12]);
    Bit(in=in[13] , load=load , out=out[13]);
    Bit(in=in[14] , load=load , out=out[14]);
    Bit(in=in[15] , load=load , out=out[15]);
}

这个没什么好说的,16位的寄存器。

RAM8

/**
 * Memory of eight 16-bit registers.
 * If load is asserted, the value of the register selected by
 * address is set to in; Otherwise, the value does not change.
 * The value of the selected register is emitted by out.
 */
CHIP RAM8 {
    IN in[16], load, address[3];
    OUT out[16];

    PARTS:

    DMux8Way(in=load , sel=address , a=load0, b=load1 , c=load2 , d=load3 , e=load4 , f=load5 , g=load6 , h=load7);
    //Only one of the value "load" is available,choose which one to operate
    Register(in=in, load=load0 , out=out0);
    Register(in=in, load=load1 , out=out1);
    Register(in=in, load=load2 , out=out2);
    Register(in=in, load=load3 , out=out3);
    Register(in=in, load=load4 , out=out4);
    Register(in=in, load=load5 , out=out5);
    Register(in=in, load=load6 , out=out6);
    Register(in=in, load=load7 , out=out7);
    //if load_n = 0,then remain the formal output
    Mux8Way16(a=out0 , b=out1 , c=out2 , d=out3 , e=out4 , f=out5 , g=out6 , h=out7 , sel=address , out=out);
    //choose which one to output
}

RAM是由寄存器堆叠而成的存储单元,我们可以对其中的每一个寄存器进行操作,所以要求我们必须去寻址,找到我们对应操作的那个寄存器的地址。

这是一个由8个寄存器堆叠而成的存储单元。第一步我们用DMux8分路器来告诉我们的存储单元要操作哪个寄存器(把load赋给我们想操作的那个数),如果load=0,输入再怎么变都是没有用的。
最后呢,我们用一个16位的8路多路复用器来进行输出的挑选。

RAM64

/**
 * Memory of sixty four 16-bit registers.
 * If load is asserted, the value of the register selected by
 * address is set to in; Otherwise, the value does not change.
 * The value of the selected register is emitted by out.
 */
CHIP RAM64 {
    IN in[16], load, address[6];
    OUT out[16];
    
    PARTS:
    DMux8Way(in=load, sel=address[3..5] , a=load0 , b=load1 , c=load2 , d=load3 , e=load4 , f=load5, g=load6 , h=load7);
    RAM8(in=in , load=load0 , address=address[0..2] , out=out0);   
    RAM8(in=in , load=load1 , address=address[0..2] , out=out1);   
    RAM8(in=in , load=load2 , address=address[0..2] , out=out2);   
    RAM8(in=in , load=load3 , address=address[0..2] , out=out3);   
    RAM8(in=in , load=load4 , address=address[0..2] , out=out4);   
    RAM8(in=in , load=load5 , address=address[0..2] , out=out5);   
    RAM8(in=in , load=load6 , address=address[0..2] , out=out6);   
    RAM8(in=in , load=load7 , address=address[0..2] , out=out7);
    Mux8Way16(a=out0, b=out1, c=out2, d=out3, e=out4, f=out5, g=out6, h=out7, sel=address[3..5], out=out);   
}

我们思路是这样的：把64个寄存器分8组,我们用address的最高三位来表示选择哪组的8个寄存器。然后再用RAM8对着8个寄存器进行操作,总体的方法还是一样的。弄懂了这个,整个分层设计的思路就没有任何问题了。

RAM512

/**
 * Memory of 512 16-bit registers.
 * If load is asserted, the value of the register selected by
 * address is set to in; Otherwise, the value does not change.
 * The value of the selected register is emitted by out.
 */
CHIP RAM512 {
    IN in[16], load, address[9];
    OUT out[16];

    PARTS:
    DMux8Way(in=load , sel=address[6..8], a=load0 , b=load1 , c=load2 , d=load3 , e=load4 , f=load5 , g=load6, h=load7 );
    RAM64(in=in , load=load0 , address=address[0..5] , out=out0 );
    RAM64(in=in , load=load1 , address=address[0..5] , out=out1 );
    RAM64(in=in , load=load2 , address=address[0..5] , out=out2 );
    RAM64(in=in , load=load3 , address=address[0..5] , out=out3 );
    RAM64(in=in , load=load4 , address=address[0..5] , out=out4 );
    RAM64(in=in , load=load5 , address=address[0..5] , out=out5 );
    RAM64(in=in , load=load6 , address=address[0..5] , out=out6 );
    RAM64(in=in , load=load7 , address=address[0..5] , out=out7 );
    Mux8Way16(a=out0 , b=out1 , c=out2 , d=out3 , e=out4 , f=out5 , g=out6 , h=out7 , sel=address[6..8] , out=out );
}

RAM4K

/**
 * Memory of 4K 16-bit registers.
 * If load is asserted, the value of the register selected by
 * address is set to in; Otherwise, the value does not change.
 * The value of the selected register is emitted by out.
 */
CHIP RAM4K {
    IN in[16], load, address[12];
    OUT out[16];

    PARTS:
    DMux8Way(in=load , sel=address[9..11] , a=load0 , b=load1 , c=load2 , d=load3 , e=load4 , f=load5 , g=load6 , h=load7 );
    RAM512(in=in , load=load0 , address=address[0..8] , out=out0 );
    RAM512(in=in , load=load1 , address=address[0..8] , out=out1 );
    RAM512(in=in , load=load2 , address=address[0..8] , out=out2 );
    RAM512(in=in , load=load3 , address=address[0..8] , out=out3 );
    RAM512(in=in , load=load4 , address=address[0..8] , out=out4 );
    RAM512(in=in , load=load5 , address=address[0..8] , out=out5 );
    RAM512(in=in , load=load6 , address=address[0..8] , out=out6 );
    RAM512(in=in , load=load7 , address=address[0..8] , out=out7 );
    Mux8Way16(a=out0 , b=out1 , c=out2 , d=out3 , e=out4 , f=out5 , g=out6 , h=out7 , sel=address[9..11] , out=out );
}

RAM16K

/**
 * Memory of 16K 16-bit registers.
 * If load is asserted, the value of the register selected by
 * address is set to in; Otherwise, the value does not change.
 * The value of the selected register is emitted by out.
 */
CHIP RAM16K {
    IN in[16], load, address[14];
    OUT out[16];

    PARTS:
    DMux4Way(in=load , sel=address[12..13] , a=load0, b=load1 , c=load2, d=load3 );
    RAM4K(in=in , load=load0 , address=address[0..11] , out=out0 );
    RAM4K(in=in , load=load1 , address=address[0..11] , out=out1 );
    RAM4K(in=in , load=load2 , address=address[0..11] , out=out2 );
    RAM4K(in=in , load=load3 , address=address[0..11] , out=out3 );
    Mux4Way16(a=out0 , b=out1 , c=out2 , d=out3 , sel=address[12..13] , out=out );
}

PC——计数器

/**
 * A 16-bit counter.
 * if      reset(t): out(t+1) = 0
 * else if load(t):  out(t+1) = in(t)
 * else if inc(t):   out(t+1) = out(t) + 1
 * else              out(t+1) = out(t)
 */
CHIP PC {
    IN in[16], reset, load, inc;
    OUT out[16];
    
    PARTS:
    Inc16(in=regOutput, out=regOutputInc);    
    Mux16(a=regOutput, b=regOutputInc, sel=inc, out=out1);
    Mux16(a=out1, b=in, sel=load, out=out2);
    Mux16(a=out2, b=false, sel=reset, out=regInput);
    
    // load == load OR inc OR reset !!!只要 reset、load 或 inc 中任意一个为真，就触发寄存器的加载。

    Or(a=load, b=inc, out=loadOrInc);
    Or(a=loadOrInc, b=reset, out=loadOrIncOrReset);
    
    Register(in=regInput, load=loadOrIncOrReset, out=regOutput);    
    
    Or16(a=false, b=regOutput, out=out); // dummy OR gate for output
}

其实计数器的芯片接口和寄存器的很类似,但是计数器芯片有两个附加的控制位reset和inc。当inc=1,计数器在每个时间周期自加;如果想要把计数器赋值为0,就把reset置为1;如果想要将计数器保持在某个值d,那就应该在输入端赋给in这个值,然后load置为1。

-------------本文结束感谢您的阅读-------------

本文作者： Arua
本文链接： https://blog.visionary-5.top/2024/10/28/NAND2Tetris%E2%80%94%E2%80%94project3/
版权声明： 本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。转载请注明出处！