精华内容
下载资源
问答
  • CSAPP

    2017-07-04 09:11:59
    不周山之读薄 CSAPP
  • csapp

    2020-02-27 00:51:36
    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • CSAPP
  • csapp-源码

    2021-03-21 20:06:48
    csapp
  • CSAPP_LAB:CSAPP实验-源码

    2021-03-09 12:28:28
    CSAPP_LAB CSAPP实验 数据实验室
  • CMU CSAPP课件

    2020-09-26 21:29:11
    CMU CSAPP课件
  • CSAPP-源码

    2021-02-26 20:09:01
    CSAPP测试与实验室
  • CSAPP的实验室 SE-118 SE-119 SE-120 @ SJTU-SE的其他项目 我构建此存储库的一个重要原因是使用github在PC和虚拟机之间交换代码。
  • CSAPP-15-213 CMU CSAPP 相关资源 日志 状态 内容 日期 :white_heavy_check_mark: 阅读3.6 2020.06.18 :white_heavy_check_mark: lec6视频:机器编程:控制 2020.06.19 :white_heavy_check_mark: 阅读3.7 ...
  • CSAPP
  • CSAPP笔记PDF

    2017-06-15 22:51:45
    自己总结的CSAPP笔记
  • CSAPP电子版

    2018-12-08 19:09:50
    CSAPP电子版,对于学习汇编、了解程序运行原理和C语言底层实现很有帮助
  • CSAPP cacheLabNote

    2017-12-13 13:55:23
    CSAPP Note chap6 CSAPP 读书笔记系列chap6 lab4 cacheLabNote

    CSAPP Note chap6

    CSAPP 读书笔记系列chap6

    lab4 cacheLabNote

    这一次实验有两个part
    - PART A :实现一个缓存模拟器,并分析根据给定的 trace 文件
    - PART B :利用缓存来加速矩阵运算(没做)

    PART A

    用C\C++来模拟cpu对cache的访问,然后统计hits、misses和eviction的次数
    其中:
    - HIT 缓存命中
    - MISS 缓存未命中
    - EVICTION 替换:替换最久没有读取过的行.也就是LRU

    编译的时候只需要简单 make clean 和 make,然后就可以进行测试了。
    测试可以
    - 单元测试 

    ./csim -s 4 -E 1 -b 4 -t traces/trans.trace
    • 总的测试,查看评分
    ./test-csim
    需要解决的难点
    • 如何从命令中拿到所需的参数 : 实验书上提醒给的是库函数 getopt,详细可以man getopt

    • 如何从文件中读入内容: 文件指针FILE* fp + 函数fets() + 函数fscanf()

    • 如何进行 cache 的存储: 动态分配一个缓冲区的大小,由s, E, b 决定

    • 进行替换处理: 加入引入时间的统计,使用LRU

    使用到的数据结构
    // cache的line定义
    typedef struct {
      int valid;       /* 每行一个的有效位 */
      int tag;         /* 每行t个的标志位 */
      int access_time; /* 每个line 的数据块的访问时间*/
    } line;
    
    // cache 的set定义
    typedef struct {
      line *lines;
    } set;
    
    typedef struct {
      /* cache: S *B*E的集合,见p426图6-25b */
      int setNum;  /*组数 */
      int lineNum; /* 每组行数 */
      set *sets;   /* 块集合 */
    
    } csimCache;
    主函数
    int main(int argc, char *argv[]) {
      int s = 0, E = 0,
          b = 0; // 命令行参数,组数S = 2^s; 行数E, 缓存字节块B = 2 ^b;
      char traceName[MAX]; // 输入的trace文件名
      FILE *fp;            // 文件指针
      csimCache cache;
      char lineBuff[MAX]; // 每一行的缓冲区
    
      getInfo(argc, argv, &s, &E, &b, traceName);
      initCache(&cache, s, E);
    
      fp = fopen(traceName, "r");
      if (!fp) {
        printf("Error: Cann't open file %s!\n", traceName);
        return -1;
      }
    
      //分析文件中每一行的缓存情况
      // fgets 从fp 读入 一行最多MAX个字符到lineBuff中
      while (NULL != fgets(lineBuff, MAX, fp)) {
        /* I  00400563,4 会比 L 7ff000370,8前少一个空格 */
        if (' ' == lineBuff[0]) {
          lineBuff[strlen(lineBuff) - 1] = '\0';
          parseTrace(&cache, lineBuff, s, E, b);
        }
      }
      fclose(fp);
      printSummary(hits, misses, evictions);
      // destructor(&cache, s, E);
      return 0;
    }
    使用到的函数
    
    // 从命令行拿到相应的参数,使用函数getopt
    int getInfo(int argc, char *argv[], int *ps, int *pE, int *pb, char *traceName);
    
    // 由s和E的值初始化cache
    int initCache(csimCache *cache, int s, int E);
    
    // 分析和统计每一行输入的缓冲区的情况
    int parseTrace(csimCache *cache, char *lineBuff, int s, int E, int b);
    
    // 由地址addr 得到容器set的序号 -- 组选择 
    int getSetBits(int addr, int s, int b);
    
    // 由地址addr 得到tag位  -- 行匹配
    int getTagBits(int addr, int s, int b);
    
    // 更新访问时间,因为使用LRU算法,替换最近最少使用的一项
    int updateAccessTime(csimCache *cache, int selset, int cl);
    
    // 析构函数,free 内存
    // 但lab里面已经嵌入释放函数,使用的时候注释掉
    
    int destructor(csimCache *cache, int s, int E);
     分析函数

    参考的是这一篇博客:
    http://blog.csdn.net/xzz_hust/article/details/8878294

    最终结果为:
    ./test-csim
                           Your simulator     Reference simulator
    Points (s,E,b)    Hits  Misses  Evicts    Hits  Misses  Evicts
        3 (1,1,1)       9       8       6       9       8       6  traces/yi2.trace
        3 (4,2,4)       4       5       2       4       5       2  traces/yi.trace
        3 (2,1,4)       2       3       1       2       3       1  traces/dave.trace
        3 (2,1,3)     167      71      67     167      71      67  traces/trans.trace
        3 (2,2,3)     201      37      29     201      37      29  traces/trans.trace
        3 (2,4,3)     212      26      10     212      26      10  traces/trans.trace
        3 (5,1,5)     231       7       0     231       7       0  traces/trans.trace
        6 (5,1,5)  265189   21775   21743  265189   21775   21743  traces/long.trace
       27
    
    
    TEST_CSIM_RESULTS=27
    实验总结
    • 注意指针的使用和传递,否则一不小心就seguament fault
    • 注意结构体的分配内存顺序,由大到小

    代码见github

    参考

    PART B

    时间关系没打算做,可以参考这篇
    http://wdxtub.com/2016/04/16/thick-csapp-lab-4/

    展开全文
  • csapp实验室-源码

    2021-02-17 14:18:34
    csapp实验室
  • csapp解决方案-源码

    2021-02-13 22:57:17
    csapp解决方案
  • csapp思维导图.zip

    2021-03-30 13:33:48
    csapp学习思维导图
  • csappcsapp.h和csapp.c

    千次阅读 2016-03-10 19:12:09
    地址:http://csapp.cs.cmu.edu/public/code.html
    地址:http://csapp.cs.cmu.edu/public/code.html
    
    展开全文
  • Homework-CSAPP-源码

    2021-04-03 09:51:37
    docker container run -it -v F:\csapp\homework:/csapp --name=csapp_env ubuntu:18.04 /bin/bash apt-get update apt-get install sudo sudo apt-get install build-essential sudo apt-get install gcc-multilib...
  • CSAPP-Labs ###深入理解计算机系统中的8大经典实验及过程 1.Bomb Labs 相关实验过程博客如下: Bomb lab 实验1,bomb1&2 Bomb lab 实验2,bomb3&4 Bomb lab 实验3,bomb5&6 Bomb lab 实验4, secert bomb...
  • CSAPP 英文版

    2018-04-13 16:23:37
    CSAPP 英文版 pdf A Tour of Computer Systems 1 1.1 Information Is Bits + Context 3 1.2 Programs Are Translated by Other Programs into Different Forms 4 1.3 It Pays to Understand How Compilation ...
  • csapp lab archlab 解答

    2020-06-21 01:00:43
    csapp的第4个lab,三个部分都有,其中第三个部分CPE是7.6左右,具体优化方法都有注释,希望对大家有帮助!
  • csapp:电脑系统-源码

    2021-03-11 16:20:51
    csapp:电脑系统
  • CSAPP bomblab

    2015-05-09 20:23:44
    CMU的CSAPP课程实验lab系列 bomblab
  • csapp DataLab

    2021-02-04 16:44:30
    csapp DataLab 占坑

    csapp DataLab

    emm,一开始做起来挺轻松的,然后到countbits直接炸裂。。最后还是查答案了。
    浮点数感觉看书糊里糊涂,全靠这几个实验让我入门了,太赞了。

    完整答案

    /* 
     * CS:APP Data Lab 
     * 
     * <Please put your name and userid here>
     * 
     * bits.c - Source file with your solutions to the Lab.
     *          This is the file you will hand in to your instructor.
     *
     * WARNING: Do not include the <stdio.h> header; it confuses the dlc
     * compiler. You can still use printf for debugging without including
     * <stdio.h>, although you might get a compiler warning. In general,
     * it's not good practice to ignore compiler warnings, but in this
     * case it's OK.  
     */
    
    #if 0
    /*
     * Instructions to Students:
     *
     * STEP 1: Read the following instructions carefully.
     */
    
    You will provide your solution to the Data Lab by
    editing the collection of functions in this source file.
    
    INTEGER CODING RULES:
     
      Replace the "return" statement in each function with one
      or more lines of C code that implements the function. Your code 
      must conform to the following style:
     
      int Funct(arg1, arg2, ...) {
          /* brief description of how your implementation works */
          int var1 = Expr1;
          ...
          int varM = ExprM;
    
          varJ = ExprJ;
          ...
          varN = ExprN;
          return ExprR;
      }
    
      Each "Expr" is an expression using ONLY the following:
      1. Integer constants 0 through 255 (0xFF), inclusive. You are
          not allowed to use big constants such as 0xffffffff.
      2. Function arguments and local variables (no global variables).
      3. Unary integer operations ! ~
      4. Binary integer operations & ^ | + << >>
        
      Some of the problems restrict the set of allowed operators even further.
      Each "Expr" may consist of multiple operators. You are not restricted to
      one operator per line.
    
      You are expressly forbidden to:
      1. Use any control constructs such as if, do, while, for, switch, etc.
      2. Define or use any macros.
      3. Define any additional functions in this file.
      4. Call any functions.
      5. Use any other operations, such as &&, ||, -, or ?:
      6. Use any form of casting.
      7. Use any data type other than int.  This implies that you
         cannot use arrays, structs, or unions.
    
     
      You may assume that your machine:
      1. Uses 2s complement, 32-bit representations of integers.
      2. Performs right shifts arithmetically.
      3. Has unpredictable behavior when shifting if the shift amount
         is less than 0 or greater than 31.
    
    
    EXAMPLES OF ACCEPTABLE CODING STYLE:
      /*
       * pow2plus1 - returns 2^x + 1, where 0 <= x <= 31
       */
      int pow2plus1(int x) {
         /* exploit ability of shifts to compute powers of 2 */
         return (1 << x) + 1;
      }
    
      /*
       * pow2plus4 - returns 2^x + 4, where 0 <= x <= 31
       */
      int pow2plus4(int x) {
         /* exploit ability of shifts to compute powers of 2 */
         int result = (1 << x);
         result += 4;
         return result;
      }
    
    FLOATING POINT CODING RULES
    
    For the problems that require you to implement floating-point operations,
    the coding rules are less strict.  You are allowed to use looping and
    conditional control.  You are allowed to use both ints and unsigneds.
    You can use arbitrary integer and unsigned constants. You can use any arithmetic,
    logical, or comparison operations on int or unsigned data.
    
    You are expressly forbidden to:
      1. Define or use any macros.
      2. Define any additional functions in this file.
      3. Call any functions.
      4. Use any form of casting.
      5. Use any data type other than int or unsigned.  This means that you
         cannot use arrays, structs, or unions.
      6. Use any floating point data types, operations, or constants.
    
    
    NOTES:
      1. Use the dlc (data lab checker) compiler (described in the handout) to 
         check the legality of your solutions.
      2. Each function has a maximum number of operations (integer, logical,
         or comparison) that you are allowed to use for your implementation
         of the function.  The max operator count is checked by dlc.
         Note that assignment ('=') is not counted; you may use as many of
         these as you want without penalty.
      3. Use the btest test harness to check your functions for correctness.
      4. Use the BDD checker to formally verify your functions
      5. The maximum number of ops for each function is given in the
         header comment for each function. If there are any inconsistencies 
         between the maximum ops in the writeup and in this file, consider
         this file the authoritative source.
    
    /*
     * STEP 2: Modify the following functions according the coding rules.
     * 
     *   IMPORTANT. TO AVOID GRADING SURPRISES:
     *   1. Use the dlc compiler to check that your solutions conform
     *      to the coding rules.
     *   2. Use the BDD checker to formally verify that your solutions produce 
     *      the correct answers.
     */
    
    
    #endif
    //1
    /* 
     * bitXor - x^y using only ~ and & 
     *   Example: bitXor(4, 5) = 1
     *   Legal ops: ~ &
     *   Max ops: 14
     *   Rating: 1
     */
    int bitXor(int x, int y) {
      return ~(~(x & ~y) & ~(~x & y));
    }
    /* 
     * tmin - return minimum two's complement integer 
     *   Legal ops: ! ~ & ^ | + << >>
     *   Max ops: 4
     *   Rating: 1
     */
    int tmin(void) {
      return 1 << 31;
    }
    //2
    /*
     * isTmax - returns 1 if x is the maximum, two's complement number,
     *     and 0 otherwise 
     *   Legal ops: ! ~ & ^ | +
     *   Max ops: 10
     *   Rating: 1
     */
    int isTmax(int x) {
      // tmin + tmax + 1 == 0
      return !(~((x + 1) + x) | !(x + 1));
    }
    /* 
     * allOddBits - return 1 if all odd-numbered bits in word set to 1
     *   where bits are numbered from 0 (least significant) to 31 (most significant)
     *   Examples allOddBits(0xFFFFFFFD) = 0, allOddBits(0xAAAAAAAA) = 1
     *   Legal ops: ! ~ & ^ | + << >>
     *   Max ops: 12
     *   Rating: 2
     */
    int allOddBits(int x) {
      // 0x1010...&x == x
      int tmp = (0xAA << 24) + (0xAA << 16) + (0xAA << 8) + 0xAA;
      return !((tmp & x) ^ tmp);
    }
    /* 
     * negate - return -x 
     *   Example: negate(1) = -1.
     *   Legal ops: ! ~ & ^ | + << >>
     *   Max ops: 5
     *   Rating: 2
     */
    int negate(int x) {
      return ~x + 1;
    }
    //3
    /* 
     * isAsciiDigit - return 1 if 0x30 <= x <= 0x39 (ASCII codes for characters '0' to '9')
     *   Example: isAsciiDigit(0x35) = 1.
     *            isAsciiDigit(0x3a) = 0.
     *            isAsciiDigit(0x05) = 0.
     *   Legal ops: ! ~ & ^ | + << >>
     *   Max ops: 15
     *   Rating: 3
     */
    int isAsciiDigit(int x) {
      /* (x - 0x30 >= 0) && (0x39 - x) >=0 */
      int NEG = 1 << 31;
      return !((x + ~0x30 + 1) & NEG) & !((0x39 + ~x + 1) & NEG);
    }
    /* 
     * conditional - same as x ? y : z 
     *   Example: conditional(2,4,5) = 4
     *   Legal ops: ! ~ & ^ | + << >>
     *   Max ops: 16
     *   Rating: 3
     */
    int conditional(int x, int y, int z) {
      int tmp = ~(!!x) + 1;
      return (tmp & y) | (~tmp & z);
    }
    /* 
     * isLessOrEqual - if x <= y  then return 1, else return 0 
     *   Example: isLessOrEqual(4,5) = 1.
     *   Legal ops: ! ~ & ^ | + << >>
     *   Max ops: 24
     *   Rating: 3
     */
    int isLessOrEqual(int x, int y) {
      // First check signBit
      int signX = x >> 31;
      int signY = y >> 31;
      return (signX & !signY) | (!(signX ^ signY) & !((y + ~x + 1) >> 31));
    }
    //4
    /* 
     * logicalNeg - implement the ! operator, using all of 
     *              the legal operators except !
     *   Examples: logicalNeg(3) = 0, logicalNeg(0) = 1
     *   Legal ops: ~ & ^ | + << >>
     *   Max ops: 12
     *   Rating: 4 
     */
    int logicalNeg(int x) {
      return ((x | (~x + 1)) >> 31) + 1;
    }
    /* howManyBits - return the minimum number of bits required to represent x in
     *             two's complement
     *  Examples: howManyBits(12) = 5
     *            howManyBits(298) = 10
     *            howManyBits(-5) = 4
     *            howManyBits(0)  = 1
     *            howManyBits(-1) = 1
     *            howManyBits(0x80000000) = 32
     *  Legal ops: ! ~ & ^ | + << >>
     *  Max ops: 90
     *  Rating: 4
     */
    int howManyBits(int x) {
      int sign, b1, b2, b4, b8, b16;
      sign = (x >> 31);
      x = (sign & ~x) | (~sign & x);
      b16 = !!(x >> 16) << 4;
      x = x >> b16;
      b8 = !!(x >> 8) << 3;
      x = x >> b8;
      b4 = !!(x >> 4) << 2;
      x = x >> b4;
      b2 = !!(x >> 2) << 1;
      x = x >> b2;
      b1 = !!(x >> 1);
      x = x >> b1;
      return b16 + b8 + b4 + b2 + b1 + x + 1;
    }
    //float
    /* 
     * floatScale2 - Return bit-level equivalent of expression 2*f for
     *   floating point argument f.
     *   Both the argument and result are passed as unsigned int's, but
     *   they are to be interpreted as the bit-level representation of
     *   single-precision floating point values.
     *   When argument is NaN, return argument
     *   Legal ops: Any integer/unsigned operations incl. ||, &&. also if, while
     *   Max ops: 30
     *   Rating: 4
     */
    unsigned floatScale2(unsigned uf) {
      int e = (uf >> 23) & 0xff;
      int sign = uf & (0x1 << 31);
      int M = (uf << 9) >> 9;
      if(M == 0 && e == 0) return uf; // 0
      if(e == 0x0) return (uf << 1) | sign;
      if(e == 0xff) return uf; // NaN
      e++;
      if(e == 0xff && M > 0) return uf;
      return sign | (e << 23) | M;
    }
    /* 
     * floatFloat2Int - Return bit-level equivalent of expression (int) f
     *   for floating point argument f.
     *   Argument is passed as unsigned int, but
     *   it is to be interpreted as the bit-level representation of a
     *   single-precision floating point value.
     *   Anything out of range (including NaN and infinity) should return
     *   0x80000000u.
     *   Legal ops: Any integer/unsigned operations incl. ||, &&. also if, while
     *   Max ops: 30
     *   Rating: 4
     */
    int floatFloat2Int(unsigned uf) {
      int e = ((uf >> 23) & 0xff)-127;
      int sign = uf >> 31;
      int M = (uf&0x007fffff)|0x00800000;
      if(!(uf&0x7fffffff)) return 0; // 0
      if(e < 0) return 0; // 0.***
      if(e > 31) return 0x80000000; // overflow
      if(!(uf & 0x7fffffff)) return 0; // 0
      /* 取整数部分 */
      if(e > 23) 
        M <<= (e - 23);
      else 
        M >>= (23 - e);
    
      if(!((M >> 31) ^ sign)) // +
        return M;
      else if(M >> 31) // overflow
        return 0x80000000;
      return ~M + 1; // -
    }
    /* 
     * floatPower2 - Return bit-level equivalent of the expression 2.0^x
     *   (2.0 raised to the power x) for any 32-bit integer x.
     *
     *   The unsigned value that is returned should have the identical bit
     *   representation as the single-precision floating-point number 2.0^x.
     *   If the result is too small to be represented as a denorm, return
     *   0. If too large, return +INF.
     * 
     *   Legal ops: Any integer/unsigned operations incl. ||, &&. Also if, while 
     *   Max ops: 30 
     *   Rating: 4
     */
    unsigned floatPower2(int x) {
      int INF = 0xff<<23;
      int exp = x + 127;
      if(exp <= 0) return 0;
      if(exp >= 255) return INF;
      return exp << 23;
    }
    
    

    isTmax

    /*
     * isTmax - returns 1 if x is the maximum, two's complement number,
     *     and 0 otherwise 
     *   Legal ops: ! ~ & ^ | +
     *   Max ops: 10
     *   Rating: 1
     */
    int isTmax(int x) {
      // tmin + tmax + 1 == 0
      return !(~((x + 1) + x) | !(x + 1));
    }
    

    禁了移位,反正就是找一些恒等式性质来排除其它的,主要一开始做想了个所有数都满足的。。也是醉了

    howManyBits

    /* howManyBits - return the minimum number of bits required to represent x in
     *             two's complement
     *  Examples: howManyBits(12) = 5
     *            howManyBits(298) = 10
     *            howManyBits(-5) = 4
     *            howManyBits(0)  = 1
     *            howManyBits(-1) = 1
     *            howManyBits(0x80000000) = 32
     *  Legal ops: ! ~ & ^ | + << >>
     *  Max ops: 90
     *  Rating: 4
     */
    int howManyBits(int x) {
      int sign, b1, b2, b4, b8, b16;
      sign = (x >> 31);
      x = (sign & ~x) | (~sign & x);
      b16 = !!(x >> 16) << 4;
      x = x >> b16;
      b8 = !!(x >> 8) << 3;
      x = x >> b8;
      b4 = !!(x >> 4) << 2;
      x = x >> b4;
      b2 = !!(x >> 2) << 1;
      x = x >> b2;
      b1 = !!(x >> 1);
      x = x >> b1;
      return b16 + b8 + b4 + b2 + b1 + x + 1;
    }
    

    题也没看懂,也不会做,折磨了好久去搜了一下,大概就是负数前面都是1,所以可以先转过来再统一处理,然后寻找高位的二分法也是让我学到了太多了。

    floatScale2

    2.0*f,主要是为下一题铺垫一下。这个还算简单,判断几个特殊情况然后把指数e加一就好了。

    //float
    /* 
     * floatScale2 - Return bit-level equivalent of expression 2*f for
     *   floating point argument f.
     *   Both the argument and result are passed as unsigned int's, but
     *   they are to be interpreted as the bit-level representation of
     *   single-precision floating point values.
     *   When argument is NaN, return argument
     *   Legal ops: Any integer/unsigned operations incl. ||, &&. also if, while
     *   Max ops: 30
     *   Rating: 4
     */
    unsigned floatScale2(unsigned uf) {
      int e = (uf >> 23) & 0xff;
      int sign = uf & (0x1 << 31);
      int M = (uf << 9) >> 9;
      if(M == 0 && e == 0) return uf; // 0
      if(e == 0x0) return (uf << 1) | sign;
      if(e == 0xff) return uf; // NaN
      e++;
      if(e == 0xff && M > 0) return uf;
      return sign | (e << 23) | M;
    }
    

    floatFloat2Int

    /* 
     * floatFloat2Int - Return bit-level equivalent of expression (int) f
     *   for floating point argument f.
     *   Argument is passed as unsigned int, but
     *   it is to be interpreted as the bit-level representation of a
     *   single-precision floating point value.
     *   Anything out of range (including NaN and infinity) should return
     *   0x80000000u.
     *   Legal ops: Any integer/unsigned operations incl. ||, &&. also if, while
     *   Max ops: 30
     *   Rating: 4
     */
    int floatFloat2Int(unsigned uf) {
      int e = ((uf >> 23) & 0xff)-127;
      int sign = uf >> 31;
      int M = (uf&0x007fffff)|0x00800000;
      if(!(uf&0x7fffffff)) return 0; // 0
      if(e < 0) return 0; // 0.***
      if(e > 31) return 0x80000000; // overflow
      if(!(uf & 0x7fffffff)) return 0; // 0
      /* 取整数部分 */
      if(e > 23) 
        M <<= (e - 23);
      else 
        M >>= (23 - e);
    
      if(!((M >> 31) ^ sign)) // +
        return M;
      else if(M >> 31) // overflow
        return 0x80000000;
      return ~M + 1; // -
    }
    

    先分离sign、e、M,基本操作了。然后判断特殊情况,之后这个判断跟23的关系是因为M只有23位,多于23的话意味着这个数是a0000.0000b的形式,否则只需直接剔除小数点后的位数,这个思路👍啊。

    总结

    做实验才勉强懂了点浮点数,做题的方法关键还是拆分三部分,特殊点判断。然后离散还得多思考多想了,毕竟这部分没深入学,而且用的好啥都能做。

    展开全文
  • CSAPP-3e-lab-code 这是CSAPP(计算机系统:程序员的观点)第三版实验作业的代码存储库。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,258
精华内容 2,503
关键字:

csapp