CSAPP:datalab

最新推荐文章于 2024-08-03 11:33:58 发布

Isaray

最新推荐文章于 2024-08-03 11:33:58 发布

阅读量281

点赞数

分类专栏：课程学习文章标签：经验分享

本文链接：https://blog.csdn.net/Isaray/article/details/113487333

版权

课程学习专栏收录该内容

6 篇文章 0 订阅

订阅专栏

CSAPP:datalab

代码中有具体思路的标注。
以下为实验的说明，每道题目中有规定一些运算符能否使用，使用的符号个数，并规定一些控制结构和函数不能使用。

datalab

CSAPP:datalab

/* 
 * CS:APP Data Lab 
 * 
 * 
 * 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

  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 an integer by more
     than the word size.

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 implent 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 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 operators (! ~ & ^ | + << >>)
     that you are allowed to use for your implementation of the function. 
     The max operator count is checked by dlc. Note that '=' 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.

以下为所需要写的函数，每个函数的说明和限制都在注释中有具体讲解。

1.bitAnd ：

不用&，而用|表示&。两者像照镜子，&是同1则1，|是同0则0，用德摩根律，一反再反刚好对称过来。

/* 
 * bitAnd - x&y using only ~ and | 
 *   Example: bitAnd(6, 5) = 4
 *   Legal ops: ~ |
 *   Max ops: 8
 *   Rating: 1
 */
int bitAnd(int x, int y) {
  /*It's equal to find the position that both are 0 and find its reversed version.有点像德摩根律。*/
  return ~(~x|~y);
 }

2.getByte:

先算数左移再算数右移，再减去算数右移增加的补位数

/* 
* getByte - Extract byte n from word x
*   Bytes numbered from 0 (LSB) to 3 (MSB)
*   Examples: getByte(0x12345678,1) = 0x56
*   Legal ops: ! ~ & ^ | + << >>
*   Max ops: 6
*   Rating: 2
*/
int getByte(int x, int n) {
 /*先算数左移再算数右移，再减去算数右移增加的补位数*/
 int t,t1,t2;
 t1=x<<((3-n)*2*4);
 t2=t1>>7*4>>4<<(2*4);
 t=(t1>>(6*4))-t2;
 return t;

}

3.logicalShift:

找出最高位的符号，然后把算数右移前面补的位数减掉即可
~n+1相当于-n
0xffffffff相当于-1

/* 
 * logicalShift - shift x to the right by n, using a logical shift
 *   Can assume that 0 <= n <= 31
 *   Examples: logicalShift(0x87654321,4) = 0x08765432
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 20
 *   Rating: 3 
 */
int logicalShift(int x, int n) {
  /*找出最高位的符号，然后把算数右移前面补的位数减掉即可*/
  int t;
  t=x>>31<<(32+(~n+1)+0xffffffff)<<1;
  t=(x>>n)&(~t); //这里用了一个mask小技巧，&mask为1的位置就会显露出来
  return t;
}

4.bitCount:

原理：通过同时批量的运算，把操作次数降下来。先理解只有两位的情况，像是将数字两两划分到一个格子里，01比较好理解，就是降次加和，操作完之后每个盒子里都是二进制表示的“1”的个数。再用0011降次加和，把两个盒子合并成一个盒子，以此类推。计数很巧妙！两位比较好想，但是从两位到四位，即把两个盒子合并到一个大盒子，这个方法也很妙！！

/*
 * bitCount - returns count of number of 1's in word
 *   Examples: bitCount(5) = 2, bitCount(7) = 3
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 40
 *   Rating: 4
 */
int bitCount(int x) {
  /*difficult*/
  /*原理：通过同时批量的运算，把操作次数降下来。先理解只有两位的情况，像是将数字两两划分到一个格子里，01比较好理解，就是降次加和，操作完之后每个盒子里都是二进制表示的“1”的个数。再用0011降次加和，把两个盒子合并成一个盒子，以此类推。计数很巧妙！两位比较好想，但是从两位到四位，即把两个盒子合并到一个大盒子，这个方法也很妙！！*/
  int mask1=0x55555555;//01(循环至32位)01010101
  int mask2=0x33333333;//0011(循环至32位)
  int mask3=0x0f0f0f0f;//00001111(循环至32位)
  int mask4=0x00ff00ff;//0000000011111111(循环至32位)
  int mask5=0x0000ffff;//00000000000000001111111111111111
  int t;
  t=(x&mask1)+((x>>1)&mask1);
  t=(t&mask2)+((t>>2)&mask2);
  t=(t&mask3)+((t>>4)&mask3);
  t=(t&mask4)+((t>>8)&mask4);
  t=(t&mask5)+((t>>16)&mask5);
  return t;
}

5.bang:

利用0的特性：相反数等于自身。其他的数，相反数和它本身之间肯定有一个负数。

/* 
 * bang - Compute !x without using !
 *   Examples: bang(3) = 0, bang(0) = 1
 *   Legal ops: ~ & ^ | + << >>
 *   Max ops: 12
 *   Rating: 4 
 */
int bang(int x) {
/*利用0的特性：相反数等于自身。其他的数，相反数和它本身之间肯定有一个负数。*/
  return ((x|(~x+1))>>31)+1 ;
}

6.tmin:

很简单。根据定义即可。

/* 
 * tmin - return minimum two's complement integer 
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 4
 *   Rating: 1
 */
int tmin(void) {
  return 1<<31;
}

7.fitsBits:

就是用两种不同方式去解读，判断能不能表示成n位有符号数。
第n位和第n位之前的位数的数字应该都相同，否则就无法表示。判断是否相同用按位与的方式。

/* 
 * fitsBits - return 1 if x can be represented as an 
 *  n-bit, two's complement integer.
 *   1 <= n <= 32
 *   Examples: fitsBits(5,3) = 0, fitsBits(-4,3) = 1
*   Legal ops: !  & ^ | + << >>
 *   Max ops: 15
 *   Rating: 2
 */
int fitsBits(int x, int n) {
  /*第n位和第n位之前的位数的数字应该都相同，否则就无法表示。*/
  return !((x<<(32-n)>>(32-n))^x);
}

8.divpwr2:

非整除情况，如果是负数的话，x>>n结果要加一(n非0)。对于对于负数~(x>>31)=0。整除情况如常。

/* 
 * divpwr2 - Compute x/(2^n), for 0 <= n <= 30
 *  Round toward zero
 *   Examples: divpwr2(15,1) = 7, divpwr2(-33,4) = -2
 *   Legal ops: !   ^ | + << >>
 *   Max ops: 15
 *   Rating: 2
 */
int divpwr2(int x, int n) {
  /*非整除情况，如果是负数的话，x>>n结果要加一(n非0)。对于对于负数~(x>>31)=0。整除情况如常。*/
  int s=!!(x>>31);
  int t=!!((x<<(32+~n+1))^0);
  return (x>>n)+(s&t&!!n);
}

9.negate:

因为 ~x+x=0xffffffff且0xffffffff=-1。所以-x= ~x+1。

/* 
 * negate - return -x 
 *   Example: negate(1) = -1.
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 5
 *   Rating: 2
 */
int negate(int x) {
  return ~x+1;
}

10.isPositive:

x-1算数右移31位，如果x=0则所有位都为0，否则所有位都为1。

/* 
 * isPositive - return 1 if x > 0, return 0 otherwise 
 *   Example: isPositive(-1) = 0.
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 8
 *   Rating: 3
 */
int isPositive(int x) {
/*x-1算数右移31位，如果x=0则所有位都为0，否则所有位都为1。*/
  return !(x>>31)&!!x;
}

11.isLessOrEqual:

即y-x>=0或y>0,x<0(若溢出)。分类讨论。（y>0,x>0,y-x>0）|（y>0,x<0）|（y<0,x<0,y-x>0）

/* 
 * 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) {
  /*即y-x>=0或y>0,x<0(若溢出)。分类讨论。*/
  return (!(y>>31)&!(x>>31)&!((y+~x+1)>>31))|((!(y>>31))&(x>>31))|((y>>31)&(x>>31)&!((y+~x+1)>>31));
}

12.ilog2:

找到x的最高的非0位。二分法处理，两部分有无1，用0、1表示；位置用1位移累加。很妙！！

/*
 * ilog2 - return floor(log base 2 of x), where x > 0
 *   Example: ilog2(16) = 4
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 90
 *   Rating: 4
 */
int ilog2(int x) {
  /*找到x的最高的非0位。二分法处理，两部分有无1，用0、1表示；位置用1位移累加。很妙！！*/
  int t;
  t=(!!(x>>16))<<4;
  t=t+((!!(x>>(8+t)))<<3);
  t=t+((!!(x>>(4+t)))<<2);
  t=t+((!!(x>>(2+t)))<<1);
  t=t+(!!(x>>(1+t)));
  return t;
}

13.float_neg:

判断是否为NaN，然后最高位取反。

/* 
 * float_neg - Return bit-level equivalent of expression -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 representations of
 *   single-precision floating point values.
 *   When argument is NaN, return argument.
 *   Legal ops: Any integer/unsigned operations incl. ||, &&. also if, while
 *   Max ops: 10
 *   Rating: 2
 */
unsigned float_neg(unsigned uf) {
/*判断是否为NaN，然后最高位取反。*/
 unsigned exp=(uf&0x7ff80000)>>23;//011111111100000000000000000000000
 unsigned frac=uf&0x7fffff;//00000000011111111111111111111111
 if(!(exp^0xff) && !!(frac^0) )//exp=0xff且frac!=0
	    return uf;//为NaN返回NaN
 return uf^0x80000000;//s位变号即可
 
}

14.float_i2f:

主要看次数+要不要进位
32-i-1+127即exp
flag是看要不要进位

/*
 * float_i2f - Return bit-level equivalent of expression (float) x
 *   Result is returned as unsigned int, but
 *   it is to be interpreted as the bit-level representation of a
 *   single-precision floating point values.
 *   Legal ops: Any integer/unsigned operations incl. ||, &&. also if, while
 *   Max ops: 30
 *   Rating: 4
 */
unsigned float_i2f(int x) {
  unsigned i=0,t;
  unsigned s=(!!(x>>31))<<31;
  if(!(x^0)) return 0;//为0则0
  if(!(x^0x80000000)) return 0xcf000000;//-2^31
  if(s) x=~x+1;//负数转换成正数
  while(!((x<<i)&0x80000000)){//高位不为1就循环
   i=i+1;
  }
  t=(x<<i)-0x80000000;
  int flag=0;//若进位，flag变成1
  if((t&0xff)>0x80) flag=1;
  else{
      if((t&0x180)==0x180) flag=1;
  }
  t=t>>8;  
  t=s+((32-i-1+127)<<23)+t+flag;//32-i-1+127即exp
  return t;
}

15.float_twice:

denormalized 的浮点数,exp全为0，乘以2只需将frac左移一位并保持符号不变
normalized 的浮点数，乘以2只需exp++

/* float_twice - 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 float_twice(unsigned uf) {
  unsigned exp=(uf&0x7ff80000)>>23;//011111111100000000000000000000000
  unsigned frac=uf&0x7fffff;//00000000011111111111111111111111
  unsigned t;
  if(!(exp^0xff) ){
       return uf;//NaN
  }
  int k=!!(uf&0x7fffffff)&!!exp;
  t=(uf&0x80000000)+((exp+k)<<23)+(frac<<!exp);//s+exp+frac//exp全0的，frac<<1,exp不变;否则exp++
  return t;
}

结果：

./btest
在这里插入图片描述

Isaray

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
CSAPP:datalab

CSAPP:datalab代码中有具体思路的标注。/* * CS:APP Data Lab * * * 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 d
复制链接

扫一扫