计算机系统要素-第一章 布尔逻辑

1 前言
    1) What I hear, I forget; What I see,I remember; What I do, I underStand.
    2) 理解硬件、软件、编译器、操作系统之间如何交互，透彻理解计算机的内部工作原理。
    3) 本书需要的工具和资源下载地址：http://www.nand2tetris.org/software.php
    4) 本书涵盖内容
       
2 基本逻辑门实现
    1) Not
        /**
         * Not gate:
         * out = not in
         */
        CHIP Not {
            IN in;
            OUT out;
       
            PARTS:
            Nand(a=in,b=in,out=out);
        }
    2) And
        /**
         * And gate:
         * out = 1 if (a == 1 and b == 1)
         *       0 otherwise
         */
       
        CHIP And {
            IN a, b;
            OUT out;
       
            PARTS:
            Nand(a=a,b=b,out=tp1);
            Nand(a=tp1,b=tp1,out=out);
        }
    3) Or
         /**
         * Or gate:
         * out = 1 if (a == 1 or b == 1)
         *       0 otherwise
         */
       
        CHIP Or {
            IN a, b;
            OUT out;
       
            PARTS:
            Nand(a=a,b=a,out=tp1);
            Nand(a=b,b=b,out=tp2);
            Nand(a=tp1,b=tp2,out=out);
        }
    4) Xor
        /**
         * Exclusive-or gate:
         * out = not (a == b)
         */
       
        CHIP Xor {
            IN a, b;
            OUT out;
       
            PARTS:
            Not(in=a,out=na);
            Not(in=b,out=nb);
            And(a=a,b=nb,out=tp1);
            And(a=na,b=b,out=tp2);
            Or(a=tp1,b=tp2,out=out);
        }
    5) Mux
        /**
         * Multiplexor:
         * out = a if sel == 0
         *       b otherwise
         */
       
        CHIP Mux {
            IN a, b, sel;
            OUT out;
       
            PARTS:
            Not(in=sel,out=nsel);
            And(a=a,b=nsel,out=tp1);
            And(a=b,b=sel,out=tp2);
            Or(a=tp1,b=tp2,out=out);
        }
    6) Dmux
        /**
         * Demultiplexor:
         * {a, b} = {in, 0} if sel == 0
         *          {0, in} if sel == 1
         */
       
        CHIP DMux {
            IN in, sel;
            OUT a, b;
       
            PARTS:
            Not(in=sel,out=nsel);
            And(a=in,b=nsel,out=a);
            And(a=in,b=sel,out=b);
        }
3 多位基本门
    1) Not16
        /**
         * 16-bit Not:
         * for i=0..15: out[i] = not in[i]
         */
       
        CHIP Not16 {
            IN in[16];
            OUT out[16];
       
            PARTS:
            Not(in=in[0],out=out[0]);
            Not(in=in[1],out=out[1]);
            Not(in=in[2],out=out[2]);
            Not(in=in[3],out=out[3]);
            Not(in=in[4],out=out[4]);
            Not(in=in[5],out=out[5]);
            Not(in=in[6],out=out[6]);
            Not(in=in[7],out=out[7]);
            Not(in=in[8],out=out[8]);
            Not(in=in[9],out=out[9]);
            Not(in=in[10],out=out[10]);
            Not(in=in[11],out=out[11]);
            Not(in=in[12],out=out[12]);
            Not(in=in[13],out=out[13]);
            Not(in=in[14],out=out[14]);
            Not(in=in[15],out=out[15]);
        }
    2) And16
        /**
         * 16-bit bitwise And:
         * for i = 0..15: out[i] = (a[i] and b[i])
         */
       
        CHIP And16 {
            IN a[16], b[16];
            OUT out[16];
       
            PARTS:
            And(a=a[0],b=b[0],out=out[0]);
            And(a=a[1],b=b[1],out=out[1]);
            And(a=a[2],b=b[2],out=out[2]);
            And(a=a[3],b=b[3],out=out[3]);
            And(a=a[4],b=b[4],out=out[4]);
            And(a=a[5],b=b[5],out=out[5]);
            And(a=a[6],b=b[6],out=out[6]);
            And(a=a[7],b=b[7],out=out[7]);
            And(a=a[8],b=b[8],out=out[8]);
            And(a=a[9],b=b[9],out=out[9]);
            And(a=a[10],b=b[10],out=out[10]);
            And(a=a[11],b=b[11],out=out[11]);
            And(a=a[12],b=b[12],out=out[12]);
            And(a=a[13],b=b[13],out=out[13]);
            And(a=a[14],b=b[14],out=out[14]);
            And(a=a[15],b=b[15],out=out[15]);
        }
    3) Or16
        /**
         * 16-bit bitwise Or:
         * for i = 0..15 out[i] = (a[i] or b[i])
         */
       
        CHIP Or16 {
            IN a[16], b[16];
            OUT out[16];
       
            PARTS:
            Or(a=a[0],b=b[0],out=out[0]);
            Or(a=a[1],b=b[1],out=out[1]);
            Or(a=a[2],b=b[2],out=out[2]);
            Or(a=a[3],b=b[3],out=out[3]);
            Or(a=a[4],b=b[4],out=out[4]);
            Or(a=a[5],b=b[5],out=out[5]);
            Or(a=a[6],b=b[6],out=out[6]);
            Or(a=a[7],b=b[7],out=out[7]);
            Or(a=a[8],b=b[8],out=out[8]);
            Or(a=a[9],b=b[9],out=out[9]);
            Or(a=a[10],b=b[10],out=out[10]);
            Or(a=a[11],b=b[11],out=out[11]);
            Or(a=a[12],b=b[12],out=out[12]);
            Or(a=a[13],b=b[13],out=out[13]);
            Or(a=a[14],b=b[14],out=out[14]);
            Or(a=a[15],b=b[15],out=out[15]);
        }
    4) Mux16
        /**
         * 16-bit multiplexor:
         * for i = 0..15 out[i] = a[i] if sel == 0
         *                        b[i] if sel == 1
         */
       
        CHIP Mux16 {
            IN a[16], b[16], sel;
            OUT out[16];
       
            PARTS:
            Mux(a=a[0],b=b[0],sel=sel,out=out[0]);
            Mux(a=a[1],b=b[1],sel=sel,out=out[1]);
            Mux(a=a[2],b=b[2],sel=sel,out=out[2]);
            Mux(a=a[3],b=b[3],sel=sel,out=out[3]);
            Mux(a=a[4],b=b[4],sel=sel,out=out[4]);
            Mux(a=a[5],b=b[5],sel=sel,out=out[5]);
            Mux(a=a[6],b=b[6],sel=sel,out=out[6]);
            Mux(a=a[7],b=b[7],sel=sel,out=out[7]);
            Mux(a=a[8],b=b[8],sel=sel,out=out[8]);
            Mux(a=a[9],b=b[9],sel=sel,out=out[9]);
            Mux(a=a[10],b=b[10],sel=sel,out=out[10]);
            Mux(a=a[11],b=b[11],sel=sel,out=out[11]);
            Mux(a=a[12],b=b[12],sel=sel,out=out[12]);
            Mux(a=a[13],b=b[13],sel=sel,out=out[13]);
            Mux(a=a[14],b=b[14],sel=sel,out=out[14]);
            Mux(a=a[15],b=b[15],sel=sel,out=out[15]);
        }
4 多通道逻辑门
    1) Or8Way
        /**
         * 8-way Or:
         * out = (in[0] or in[1] or ... or in[7])
         */
       
        CHIP Or8Way {
            IN in[8];
            OUT out;
       
            PARTS:
            Or(a=in[0],b=in[1],out=tp1);
            Or(a=in[2],b=in[3],out=tp2);
            Or(a=in[4],b=in[5],out=tp3);
            Or(a=in[6],b=in[7],out=tp4);
            Or(a=tp1,b=tp2,out=tp5);
            Or(a=tp3,b=tp4,out=tp6);
            Or(a=tp5,b=tp6,out=out);
        }
    2) Mux4Way16
        /**
         * 4-way 16-bit multiplexor:
         * out = a if sel == 00
         *       b if sel == 01
         *       c if sel == 10
         *       d if sel == 11
         */
       
        CHIP Mux4Way16 {
            IN a[16], b[16], c[16], d[16], sel[2];
            OUT out[16];
       
            PARTS:   
            Mux16(a=a,b=b,sel=sel[0],out=tp1);
            Mux16(a=c,b=d,sel=sel[0],out=tp2);
            Mux16(a=tp1,b=tp2,sel=sel[1],out=out);
        }
    3) Mux8Way16
        /**
         * 8-way 16-bit multiplexor:
         * out = a if sel == 000
         *       b if sel == 001
         *       etc.
         *       h if sel == 111
         */
       
        CHIP Mux8Way16 {
            IN a[16], b[16], c[16], d[16],
               e[16], f[16], g[16], h[16],
               sel[3];
            OUT out[16];
       
            PARTS:
            Mux4Way16(a=a,b=b,c=c,d=d,sel=sel[0..1],out=tp1);
            Mux4Way16(a=e,b=f,c=g,d=h,sel=sel[0..1],out=tp2);
            Mux16(a=tp1,b=tp2,sel=sel[2],out=out);
        }
    4) DMux4Way
        /**
         * 4-way demultiplexor:
         * {a, b, c, d} = {in, 0, 0, 0} if sel == 00
         *                {0, in, 0, 0} if sel == 01
         *                {0, 0, in, 0} if sel == 10
         *                {0, 0, 0, in} if sel == 11
         */
       
        CHIP DMux4Way {
            IN in, sel[2];
            OUT a, b, c, d;
       
            PARTS:
            Not(in=sel[0],out=nsel0);
            Not(in=sel[1],out=nsel1);
           
            And(a=in,b=nsel0,out=a1);
            And(a=a1,b=nsel1,out=a);
           
            And(a=in,b=sel[0],out=b1);
            And(a=b1,b=nsel1,out=b);
           
            And(a=in,b=nsel0,out=c1);
            And(a=c1,b=sel[1],out=c);
           
            And(a=in,b=sel[0],out=d1);
            And(a=d1,b=sel[1],out=d);
        }
    5) DMux8Way
        /**
         * 8-way demultiplexor:
         * {a, b, c, d, e, f, g, h} = {in, 0, 0, 0, 0, 0, 0, 0} if sel == 000
         *                            {0, in, 0, 0, 0, 0, 0, 0} if sel == 001
         *                            etc.
         *                            {0, 0, 0, 0, 0, 0, 0, in} if sel == 111
         */
       
        CHIP DMux8Way {
            IN in, sel[3];
            OUT a, b, c, d, e, f, g, h;
       
            PARTS:
            DMux4Way(in=in,sel=sel[0..1],a=a1,b=b1,c=c1,d=d1);
            DMux4Way(in=in,sel=sel[0..1],a=e1,b=f1,c=g1,d=h1);
            Not(in=sel[2],out=nsel2);
            And(a=a1,b=nsel2,out=a);
            And(a=b1,b=nsel2,out=b);
            And(a=c1,b=nsel2,out=c);
            And(a=d1,b=nsel2,out=d);
            And(a=e1,b=sel[2],out=e);
            And(a=f1,b=sel[2],out=f);
            And(a=g1,b=sel[2],out=g);
            And(a=h1,b=sel[2],out=h);
        }

时间： 2024-08-25 21:06:43

计算机系统要素-第一章 布尔逻辑的相关文章

2018-2019-1 20189215 《深入理解计算机系统》第一章

第一章 计算机系统漫游 主要内容 全面精炼的概括了本书的内容,也就是"计算机系统概述",包括: 1.解释计算机系统中"信息"的概念:就是二进制位: 2.解释源程序(以C源程序为例)到可执行程序的过程:预处理 → 编译 → 汇编 → 链接 3.通过可执行程序被shell加载执行流程,讲解了计算机的硬件组成: 总线.I/O设备.主存.处理器. 4.高级缓存的作用以及计算机存储设备的体系结构--金字塔层次结构. 5.解释了操作系统.应用进程.计算机硬件三者之间的关系:操作

《深入理解计算机系统》第一章计算机系统漫游

信息就是位+上下文 系统中所有信息都是由一串位表示的.区分不同数据对象的唯一方法是我们读到这些数据对象时的上下文. 程序被其他程序翻译成不同的格式     范例代码 1 #include <stdio.h> 2 3 4 5 int main() 6 7 { 8 9 printf("hello world\n"); 10 11 } 每条C语言都必须被其他程序转化为机器指令,以可执行目标程序的格式打包好,以二进制文件形式存放 转化过程分为: 预处理阶段:读取系统头文件stdio

深入理解计算机系统，第一章：漫游

计算机系统漫游 1.1 信息就是位+上下文 先看一个简单的Hello World C程序. 1 #include <stdio.h> 2 3 void main() 4 { 5 printf("Hello World!\n"); 6 } 这个程序的源文件是文本格式,以字节序列的方式存储在文件中,由一种叫ASCII码的方式编码.除了文本文件之外的其它文件都是二进制文件. 由HelloWorld程序的存储方式可以猜测,信息,包括磁盘文件.内存中运行的程序.内存中储存的用户数据以

计算机系统要素-第二章 布尔运算

1 本章构建完整的算术逻辑单元ALU.2 有符号的二进制数    1) 补码:x的补码=2的n次方-x,即反码+1    2) 减法可以看成x-y=x+(-y)3 加法器    1) HalfAdder 半加器        /**         * Computes the sum of two bits.         */                CHIP HalfAdder {            IN a, b;    // 1-bit inputs           

《深入理解计算机系统》 第一章读书笔记

最近开始啃CSAPP,买了英文版,看得比较慢.只有先理解系统才能在更多方面学的更明其实质 Chapter1: * 一份hello.c代码的编译分为四个阶段:1.Pre-processor:编译预处理,就是把#include后面的库代码加入到程序中,生成hello.i的文件. 2.Complier:用编译器把hello.i的C代码翻译成汇编语言,并生成:hello.s文件.(汇编语言是高级语言转为机器码的一个中间过程) 3.Assembler:汇编机把汇编语言翻译成机器二进制代码,生成hello.

《深入理解计算机系统》第一章学习笔记

信息就是位+上下文 源程序:就是一个由0和1组合的位(bit)序列,8位组成一字(byte),每个字节表示某个文本字符. 系统中所有的信息--包括磁盘文件.存储器中的程序.存储器中存放的用户数据以及网络上传送的数据,都是由一串位表示的.区分不同数据对象的唯一方法是我们读到这些数据对象时的上下文. C语言的起源: 由Dennis Ritchie在1969年~1973年创建的. 美国国家标准学会(American National Standards Institute,ANSI)在1989年颁布了

读书笔记_深入理解计算机系统_第一章_计算机系统漫游

hello.c #incude <stdio.h> int main() { printf("Hello,world\n"); } 1.1信息就是位+上下文 系统所有的信息,都是由一串位表示的. 在不同的上下文中(可以理解为程序,或者运算),一个同样的字节序列可能表示一个整数,浮点数,字符串或者机器指令. 2.2程序被其他程序翻译成不同的格式 如Hello程序,从源文件hello.c中的每条C语句,需被其他程序转换为一系列低级语言(汇编)指令,然后将这些指令按照一种称为可执

第一章 数字逻辑基础 （西交）

计算机组成原理_第一章：计算机系统概论

第一章:计算机系统概论 1.1 计算机系统简介 问题1:现代计算机系统由那两部分组成? 现代计算机的多态性 CPS:信息物理系统 HPC:高速计算机,天河2号,Titan(Cray公司的,科磊公司) TF:TFlop/s:TF是千万亿次单位,每秒多少千万亿次计算. 顶层的抽象,然后再一步一步的细化. 基本结构都具有共性特征 两部分:硬件和软件(物理和逻辑?) 一般分为9层 1.2 计算机系统的层次结构 (程序员视角) (从最低到最高) 微指令系统--微程序机器M0,向下发展的语言.-- 由硬件直