NAND2Tetris:带你从零开始手搓计算机之项目2——搭建AlU：算数逻辑单元

总述

算术逻辑单元(arithmetic and logic unit) 是能实现多组算术运算和逻辑运算的组合逻辑电路，简称ALU。

我们熟知的冯诺依曼结构是是一种将程序指令存储器和数据存储器合并在一起的电脑设计概念结构。本结构隐约指导了将存储设备与中央处理器分开的概念，因此依本结构设计出的计算机又称存储程序计算机。

存储程序计算机在体系结构上主要特点有：

以运算单元为中心
采用存储程序原理
存储器是按地址访问、线性编址的空间
控制流由指令流产生
指令由操作码和地址码组成
数据以二进制编码

在这个项目中，我们会实现一些基本的运算芯片以及一个相对简化但是同样功能强大的ALU。整个芯片的搭建会用到在第一个项目中已经搭建好的15个逻辑门，我们分别要实现的内容包括：半加器、全加器、16位的加法器、16位的递增器以及最终实现ALU。

HalfAdder

CHIP HalfAdder {
    IN a, b;    // 1-bit inputs
    OUT sum,    // Right bit of a + b 
        carry;  // Left bit of a + b

    PARTS:
    And(a=a, b=b, out=carry);   // Carry is a AND b
    Xor(a=a, b=b, out=sum);     // Sum is a XOR b
}

FullAdder

CHIP FullAdder {
    IN a, b, c;  // 1-bit inputs
    OUT sum,     // Right bit of a + b + c
        carry;   // Left bit of a + b + c

    PARTS:
     // First Half Adder: adds a and b
    HalfAdder(a=a, b=b, sum=sum1, carry=carry1);
    
    // Second Half Adder: adds sum1 and c
    HalfAdder(a=sum1, b=c, sum=sum, carry=carry2);
    
    // Carry output: carry1 OR carry2
    Or(a=carry1, b=carry2, out=carry);
}

Add16

CHIP Add16 {
    IN a[16], b[16];
    OUT out[16];

    PARTS:
    // 第一位的全加器，初始进位为false（0）
    FullAdder(a=a[0], b=b[0], c=false, sum=out[0], carry=c1);

    // 使用16位的并行操作方式来进行进位传播
    FullAdder(a=a[1], b=b[1], c=c1, sum=out[1], carry=c2);
    FullAdder(a=a[2], b=b[2], c=c2, sum=out[2], carry=c3);
    FullAdder(a=a[3], b=b[3], c=c3, sum=out[3], carry=c4);
    FullAdder(a=a[4], b=b[4], c=c4, sum=out[4], carry=c5);
    FullAdder(a=a[5], b=b[5], c=c5, sum=out[5], carry=c6);
    FullAdder(a=a[6], b=b[6], c=c6, sum=out[6], carry=c7);
    FullAdder(a=a[7], b=b[7], c=c7, sum=out[7], carry=c8);
    FullAdder(a=a[8], b=b[8], c=c8, sum=out[8], carry=c9);
    FullAdder(a=a[9], b=b[9], c=c9, sum=out[9], carry=c10);
    FullAdder(a=a[10], b=b[10], c=c10, sum=out[10], carry=c11);
    FullAdder(a=a[11], b=b[11], c=c11, sum=out[11], carry=c12);
    FullAdder(a=a[12], b=b[12], c=c12, sum=out[12], carry=c13);
    FullAdder(a=a[13], b=b[13], c=c13, sum=out[13], carry=c14);
    FullAdder(a=a[14], b=b[14], c=c14, sum=out[14], carry=c15);
    FullAdder(a=a[15], b=b[15], c=c15, sum=out[15], carry=ignore);  // 最后的进位忽略
}

Inc16

CHIP Inc16 {
    IN in[16];
    OUT out[16];

    PARTS:
    // 低位与 1 相加，初始进位为 0
    HalfAdder(a=in[0], b=true, sum=out[0], carry=c1);

    // 继续处理进位，并与 in 的每一位相加
    FullAdder(a=in[1], b=false, c=c1, sum=out[1], carry=c2);
    FullAdder(a=in[2], b=false, c=c2, sum=out[2], carry=c3);
    FullAdder(a=in[3], b=false, c=c3, sum=out[3], carry=c4);
    FullAdder(a=in[4], b=false, c=c4, sum=out[4], carry=c5);
    FullAdder(a=in[5], b=false, c=c5, sum=out[5], carry=c6);
    FullAdder(a=in[6], b=false, c=c6, sum=out[6], carry=c7);
    FullAdder(a=in[7], b=false, c=c7, sum=out[7], carry=c8);
    FullAdder(a=in[8], b=false, c=c8, sum=out[8], carry=c9);
    FullAdder(a=in[9], b=false, c=c9, sum=out[9], carry=c10);
    FullAdder(a=in[10], b=false, c=c10, sum=out[10], carry=c11);
    FullAdder(a=in[11], b=false, c=c11, sum=out[11], carry=c12);
    FullAdder(a=in[12], b=false, c=c12, sum=out[12], carry=c13);
    FullAdder(a=in[13], b=false, c=c13, sum=out[13], carry=c14);
    FullAdder(a=in[14], b=false, c=c14, sum=out[14], carry=c15);
    FullAdder(a=in[15], b=false, c=c15, sum=out[15], carry=ignore); // 忽略最终进位
}

ALU

CHIP ALU {
    IN  
        x[16], y[16],  // 16-bit inputs        
        zx, // zero the x input?
        nx, // negate the x input?
        zy, // zero the y input?
        ny, // negate the y input?
        f,  // compute (out = x + y) or (out = x & y)?
        no; // negate the out output?
    OUT 
        out[16], // 16-bit output
        zr,      // if (out == 0) equals 1, else 0
        ng;      // if (out < 0)  equals 1, else 0

    PARTS:
     // 第一步：根据 zx 和 zy 控制信号决定是否将 x 和 y 清零
    Mux16(a=x, b=false, sel=zx, out=xZeroed);
    Mux16(a=y, b=false, sel=zy, out=yZeroed);

    // 第二步：根据 nx 和 ny 控制信号决定是否取反 x 和 y
    Not16(in=xZeroed, out=xNot);
    Not16(in=yZeroed, out=yNot);
    Mux16(a=xZeroed, b=xNot, sel=nx, out=xProcessed);
    Mux16(a=yZeroed, b=yNot, sel=ny, out=yProcessed);

    // 第三步：根据 f 控制信号决定执行加法或按位与运算
    Add16(a=xProcessed, b=yProcessed, out=xySum);
    And16(a=xProcessed, b=yProcessed, out=xyAnd);
    Mux16(a=xyAnd, b=xySum, sel=f, out=outF);

    // 第四步：根据 no 控制信号决定是否对最终结果取反
    Not16(in=outF, out=outNot);
    Mux16(a=outF, b=outNot, sel=no, out=out);
}

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

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