《计算机系统要素》学习笔记：第二章布尔运算

1.学习要点
1）本章内容涉及数字电路中加法器的构建，以及二进制数据在计算机中的计算方式，重点和难点为ALU的理解和实现。
2）重点理解补码运算。
补码：x的补码=2的n次方-x，即反码+1
减法可以看成x-y=x+(-y)
3）重点理解P37的ALU真值表，最好代入相应值计算理解，同时整个过程与补码运算密切相关，真值表同时暗示电路结构，即各个控制位之间的前后顺序，ZX在NX之前，ZY在NY之前。
4）ALU电路实现的难点在于选择电路的实现和最后的状态识别，选择电路的实现使用数据选择器，6个控制位分别对应一个MUX，状态识别通过构造与门，或门来判断（Or16Way需要新建hdl文件，并自己构建）。

2.代码实现
（1）半加器

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

            PARTS:
            Xor(a=a,b=b,out=sum);
            And(a=a,b=b,out=carry);
        }

（2）全加器

        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:
            HalfAdder(a=a,b=b,sum=s1,carry=c1);
            HalfAdder(a=s1,b=c,sum=sum,carry=c2);
            Or(a=c1,b=c2,out=carry);
        }

（3） Add16 16位加法器

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

            PARTS:
                HalfAdder(a=a[0],b=b[0],sum=out[0],carry=c1);
            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=c16);
        }

（4）增量器

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

            PARTS:
            Add16(a=in,b[1..15]=false,b[0]=true,out=out);
        }

（5）算术逻辑单元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 (if 1) or x & y (if 0)
                no; // negate the out output?

            OUT 
                out[16], // 16-bit output
                zr, // 1 if (out == 0), 0 otherwise
                ng; // 1 if (out < 0),  0 otherwise

            PARTS:
            Mux16(a=x,b[0..15]=false,sel=zx,out=x1);    
            Not16(in=x1,out=nx1);
            Mux16(a=x1,b=nx1,sel=nx,out=x2);

            Mux16(a=y,b[0..15]=false,sel=zy,out=y1);    
            Not16(in=y1,out=ny1);
            Mux16(a=y1,b=ny1,sel=ny,out=y2);

            Add16(a=x2,b=y2,out=o1);
            And16(a=x2,b=y2,out=o2);

            Mux16(a=o2,b=o1,sel=f,out=o3);

            Not16(in=o3,out=no3);
            Mux16(a=o3,b=no3,sel=no,out=o4);        

            And16(a[0..15]=true,b=o4,out=out);
            Or16Way(in=o4,out=o5);
            Not(in=o5,out=zr);
            And16(a=o4,b[0..14]=false,b[15]=true,out=ng1);    
            Or16Way(in=ng1,out=ng);    
        }